home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / misc / gnuplot-3.7src.lha / gnuplot-3.7src / gnuplot-3.7.lha / gnuplot-3.7 / graphics.c < prev    next >
C/C++ Source or Header  |  1999-01-12  |  132KB  |  4,509 lines
  1. #ifndef lint
  2. static char *RCSid = "$Id: graphics.c,v 1.138 1998/06/18 14:55:08 ddenholm Exp $";
  3. #endif
  4.  
  5. /* GNUPLOT - graphics.c */
  6.  
  7. /*[
  8.  * Copyright 1986 - 1993, 1998   Thomas Williams, Colin Kelley
  9.  *
  10.  * Permission to use, copy, and distribute this software and its
  11.  * documentation for any purpose with or without fee is hereby granted,
  12.  * provided that the above copyright notice appear in all copies and
  13.  * that both that copyright notice and this permission notice appear
  14.  * in supporting documentation.
  15.  *
  16.  * Permission to modify the software is granted, but not the right to
  17.  * distribute the complete modified source code.  Modifications are to
  18.  * be distributed as patches to the released version.  Permission to
  19.  * distribute binaries produced by compiling modified sources is granted,
  20.  * provided you
  21.  *   1. distribute the corresponding source modifications from the
  22.  *    released version in the form of a patch file along with the binaries,
  23.  *   2. add special version identification to distinguish your version
  24.  *    in addition to the base release version number,
  25.  *   3. provide your name and address as the primary contact for the
  26.  *    support of your modified version, and
  27.  *   4. retain our contact information in regard to use of the base
  28.  *    software.
  29.  * Permission to distribute the released version of the source code along
  30.  * with corresponding source modifications in the form of a patch file is
  31.  * granted with same provisions 2 through 4 for binary distributions.
  32.  *
  33.  * This software is provided "as is" without express or implied warranty
  34.  * to the extent permitted by applicable law.
  35. ]*/
  36.  
  37.  
  38. #include "plot.h"
  39. #include "setshow.h"
  40.  
  41. /* key placement is calculated in boundary, so we need file-wide variables
  42.  * To simplify adjustments to the key, we set all these once [depends on
  43.  * key_reverse] and use them throughout.
  44.  */
  45.  
  46. /*{{{  local and global variables */
  47. static int key_sample_width;    /* width of line sample */
  48. static int key_sample_left;    /* offset from x for left of line sample */
  49. static int key_sample_right;    /* offset from x for right of line sample */
  50. static int key_point_offset;    /* offset from x for point sample */
  51. static int key_text_left;    /* offset from x for left-justified text */
  52. static int key_text_right;    /* offset from x for right-justified text */
  53. static int key_size_left;    /* size of left bit of key (text or sample, depends on key_reverse) */
  54. static int key_size_right;    /* size of right part of key (including padding) */
  55.  
  56. /* I think the following should also be static ?? */
  57.  
  58. static int key_xl, key_xr, key_yt, key_yb;    /* boundarys for key field */
  59. static int max_ptitl_len = 0;    /* max length of plot-titles (keys) */
  60. static int ktitl_lines = 0;    /* no lines in key_title (key header) */
  61. static int ptitl_cnt;        /* count keys with len > 0  */
  62. static int key_cols;        /* no cols of keys */
  63. static int key_rows, key_col_wth, yl_ref;
  64.  
  65.  
  66. /* penalty for doing tics by callback in gen_tics is need for
  67.  * global variables to communicate with the tic routines
  68.  * Dont need to be arrays for this
  69.  */
  70. static int tic_start, tic_direction, tic_text, rotate_tics, tic_hjust, tic_vjust, tic_mirror;
  71.  
  72. /* set by tic_callback - how large to draw polar radii */
  73. static double largest_polar_circle;
  74.  
  75. /* either xformat etc or invented time format
  76.  * index with FIRST_X_AXIS etc
  77.  * global because used in gen_tics, which graph3d also uses
  78.  */
  79. char ticfmt[8][MAX_ID_LEN+1]; /* HBB 990106: fix buffer overrun */
  80. int timelevel[8];
  81. double ticstep[8];
  82.  
  83. static int xlablin, x2lablin, ylablin, y2lablin, titlelin, xticlin, x2ticlin;
  84.  
  85. static int key_entry_height;    /* bigger of t->v_size, pointsize*t->v_tick */
  86. static int p_width, p_height;    /* pointsize * { t->h_tic | t->v_tic } */
  87.  
  88.  
  89. /* there are several things on right of plot - key, y2tics and y2label
  90.  * when working out boundary, save posn of y2label for later...
  91.  * Same goes for x2label.
  92.  * key posn is also stored in key_xl, and tics go at xright
  93.  */
  94. static int ylabel_x, y2label_x, xlabel_y, x2label_y, title_y, time_y, time_x;
  95. static int ylabel_y, y2label_y, xtic_y, x2tic_y, ytic_x, y2tic_x;
  96. /*}}} */
  97.  
  98. /*{{{  static fns and local macros */
  99. static void plot_impulses __PROTO((struct curve_points * plot, int yaxis_x,
  100.                    int xaxis_y));
  101. static void plot_lines __PROTO((struct curve_points * plot));
  102. static void plot_points __PROTO((struct curve_points * plot));
  103. static void plot_dots __PROTO((struct curve_points * plot));
  104. static void plot_bars __PROTO((struct curve_points * plot));
  105. static void plot_boxes __PROTO((struct curve_points * plot, int xaxis_y));
  106. static void plot_vectors __PROTO((struct curve_points * plot));
  107. static void plot_f_bars __PROTO((struct curve_points * plot));
  108. static void plot_c_bars __PROTO((struct curve_points * plot));
  109.  
  110. static void edge_intersect __PROTO((struct coordinate GPHUGE * points, int i,
  111.                     double *ex, double *ey));
  112. static int two_edge_intersect __PROTO((struct coordinate GPHUGE * points,
  113.                     int i, double *lx, double *ly));
  114. static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
  115.  
  116. static void plot_steps __PROTO((struct curve_points * plot));    /* JG */
  117. static void plot_fsteps __PROTO((struct curve_points * plot));    /* HOE */
  118. static void plot_histeps __PROTO((struct curve_points * plot));    /* CAC */
  119. static void histeps_horizontal __PROTO((int *xl, int *yl, double x1, double x2,
  120.                     double y));             /* CAC */
  121. static void histeps_vertical __PROTO((int *xl, int *yl, double x, double y1,
  122.                     double y2));        /* CAC */
  123. static void edge_intersect_steps __PROTO((struct coordinate GPHUGE * points,
  124.                 int i, double *ex, double *ey)); /* JG */
  125. static void edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points,
  126.                 int i, double *ex, double *ey)); /* HOE */
  127. static TBOOLEAN two_edge_intersect_steps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));                /* JG */
  128. static TBOOLEAN two_edge_intersect_fsteps __PROTO((struct coordinate GPHUGE * points, int i, double *lx, double *ly));
  129.  
  130. static double LogScale __PROTO((double coord, int is_log, double log_base_log,
  131.                 char *what, char *axis));
  132. static double dbl_raise __PROTO((double x, int y));
  133. static void boundary __PROTO((int scaling, struct curve_points * plots,
  134.                 int count));
  135. static double make_tics __PROTO((int axis, int guide));
  136.  
  137. /* widest2d_callback keeps longest so far in here */
  138. static int widest_tic;
  139.  
  140. static void widest2d_callback __PROTO((int axis, double place, char *text,
  141.                     struct lp_style_type grid));
  142. static void ytick2d_callback __PROTO((int axis, double place, char *text,
  143.                     struct lp_style_type grid));
  144. static void xtick2d_callback __PROTO((int axis, double place, char *text,
  145.                     struct lp_style_type grid));
  146. static void map_position __PROTO((struct position * pos, unsigned int *x,
  147.                     unsigned int *y, char *what));
  148. static void mant_exp __PROTO((double log_base, double x, int scientific,
  149.                 double *m, int *p));
  150. static void gprintf __PROTO((char *dest, size_t count, char *format,
  151.                 double log_base, double x));
  152.  
  153. #if defined(sun386) || defined(AMIGA_SC_6_1)
  154. static double CheckLog __PROTO((TBOOLEAN is_log, double base_log, double x));
  155. #endif
  156.  
  157. /* for plotting error bars
  158.  * half the width of error bar tic mark
  159.  */
  160. #define ERRORBARTIC (t->h_tic/2)
  161.  
  162. /*
  163.  * The Amiga SAS/C 6.2 compiler moans about macro envocations causing
  164.  * multiple calls to functions. I converted these macros to inline
  165.  * functions coping with the problem without loosing speed.
  166.  * If your compiler supports __inline, you should add it to the
  167.  * #ifdef directive
  168.  * (MGR, 1993)
  169.  */
  170.  
  171. #ifdef AMIGA_SC_6_1
  172. GP_INLINE static TBOOLEAN i_inrange(int z, int min, int max)
  173. {
  174.     return ((min < max) ? ((z >= min) && (z <= max)) : ((z >= max) && (z <= min)));
  175. }
  176.  
  177. GP_INLINE static double f_max(double a, double b)
  178. {
  179.     return (GPMAX(a, b));
  180. }
  181.  
  182. GP_INLINE static double f_min(double a, double b)
  183. {
  184.     return (GPMIN(a, b));
  185. }
  186.  
  187. #else
  188. #define f_max(a,b) GPMAX((a),(b))
  189. #define f_min(a,b) GPMIN((a),(b))
  190. #define i_inrange(z,a,b) inrange((z),(a),(b))
  191. #endif
  192.  
  193. /* True if a and b have the same sign or zero (positive or negative) */
  194. #define samesign(a,b) ((a) * (b) >= 0)
  195. /*}}} */
  196.  
  197. /*{{{  more variables */
  198. /* Define the boundary of the plot
  199.  * These are computed at each call to do_plot, and are constant over
  200.  * the period of one do_plot. They actually only change when the term
  201.  * type changes and when the 'set size' factors change.
  202.  * - no longer true, for 'set key out' or 'set key under'. also depend
  203.  * on tic marks and multi-line labels.
  204.  * They are shared with graph3d.c since we want to use its draw_clip_line()
  205.  */
  206. int xleft, xright, ybot, ytop;
  207.  
  208.  
  209. /* we make a local copy of the 'key' variable so that if something
  210.  * goes wrong, we can switch it off temporarily
  211.  */
  212.  
  213. static int lkey;
  214.  
  215. /* First attempt at double axes...
  216.  * x_min etc are now accessed from a global array min_array[], max_array[]
  217.  * put the scale factors into a similar array
  218.  * for convenience in this first attack on double axes, just define x_min etc
  219.  * since code already uses x_min, etc  Eventually it will be done properly
  220.  */
  221.  
  222.  
  223. extern double min_array[], max_array[];
  224. extern int auto_array[];
  225.  
  226. extern int log_array[];
  227. extern double base_array[], log_base_array[];
  228.  
  229. static int x_axis = FIRST_X_AXIS, y_axis = FIRST_Y_AXIS;    /* current axes */
  230.  
  231. static double scale[AXIS_ARRAY_SIZE];    /* scale factors for mapping for each axis */
  232.  
  233. /* BODGES BEFORE I FIX IT UP */
  234. #define x_min min_array[x_axis]
  235. #define x_max max_array[x_axis]
  236. #define y_min min_array[y_axis]
  237. #define y_max max_array[y_axis]
  238.  
  239. /* And the functions to map from user to terminal coordinates */
  240. /* maps floating point x to screen */
  241. #define map_x(x) (int)(xleft+(x-min_array[x_axis])*scale[x_axis]+0.5)
  242. /* same for y */
  243. #define map_y(y) (int)(ybot +(y-min_array[y_axis])*scale[y_axis]+0.5)
  244.  
  245. /* (DFK) Watch for cancellation error near zero on axes labels */
  246. /* less than one hundredth of a tic mark */
  247. #define SIGNIF (0.01)
  248. #define CheckZero(x,tic) (fabs(x) < ((tic) * SIGNIF) ? 0.0 : (x))
  249. #define NearlyEqual(x,y,tic) (fabs((x)-(y)) < ((tic) * SIGNIF))
  250. /*}}} */
  251.  
  252. /*{{{  CheckLog() */
  253. /* (DFK) For some reason, the Sun386i compiler screws up with the CheckLog 
  254.  * macro, so I write it as a function on that machine.
  255.  *
  256.  * Amiga SAS/C 6.2 thinks it will do too much work calling functions in
  257.  * macro arguments twice, thus I inline theese functions. (MGR, 1993)
  258.  * If your compiler doesn't handle those macros correctly, you should
  259.  * also subscribe here. Even without inlining you gain speed with log plots
  260.  */
  261. #if defined(sun386) || defined(AMIGA_SC_6_1)
  262. GP_INLINE static double CheckLog(is_log, base_log, x)
  263. TBOOLEAN is_log;
  264. double base_log;
  265. double x;
  266. {
  267.     if (is_log)
  268.     return (pow(base_log, x));
  269.     else
  270.     return (x);
  271. }
  272. #else
  273. /* (DFK) Use 10^x if logscale is in effect, else x */
  274. #define CheckLog(is_log, base_log, x) ((is_log) ? pow(base_log, (x)) : (x))
  275. #endif /* sun386 || SAS/C */
  276. /*}}} */
  277.  
  278. /*{{{  LogScale() */
  279. static double LogScale(coord, is_log, log_base_log, what, axis)
  280. double coord;            /* the value */
  281. TBOOLEAN is_log;        /* is this axis in logscale? */
  282. double log_base_log;        /* if so, the log of its base */
  283. char *what;            /* what is the coord for? */
  284. char *axis;            /* which axis is this for ("x" or "y")? */
  285. {
  286.     if (is_log) {
  287.     if (coord <= 0.0) {
  288.         char errbuf[100];    /* place to write error message */
  289.         (void) sprintf(errbuf, "%s has %s coord of %g; must be above 0 for log scale!",
  290.                what, axis, coord);
  291.         graph_error(errbuf);
  292.     } else
  293.         return (log(coord) / log_base_log);
  294.     }
  295.     return (coord);
  296. }
  297. /*}}} */
  298.  
  299. /*{{{  graph_error() */
  300. /* handle errors during graph-plot in a consistent way */
  301. void graph_error(text)
  302. char *text;
  303. {
  304.     multiplot = FALSE;
  305.     term_end_plot();
  306.     int_error(text, NO_CARET);
  307. }
  308.  
  309. /*}}} */
  310.  
  311.  
  312. /*{{{  fixup_range() */
  313. /*
  314.  * === SYNOPSIS ===
  315.  *
  316.  * This function checks whether the data and/or plot range in a given axis
  317.  * is too small (which would cause divide-by-zero and/or infinite-loop
  318.  * problems later on).  If so,
  319.  * - if autoscaling is in effect for this axis, we widen the range
  320.  * - otherwise, we abort with a call to  int_error()  (which prints out
  321.  *   a suitable error message, then (hopefully) aborts this command and
  322.  *   returns to the command prompt or whatever).
  323.  *
  324.  *
  325.  * === HISTORY AND DESIGN NOTES ===
  326.  *
  327.  * 1998 Oct 4, Jonathan Thornburg <jthorn@galileo.thp.univie.ac.at>
  328.  *
  329.  * This function used to be a (long) macro  FIXUP_RANGE(AXIS, WHICH)
  330.  * which was (identically!) defined in  plot2d.c  and  plot3d.c .  As
  331.  * well as now being a function instead of a macro, the logic is also
  332.  * changed:  The "too small" range test no longer depends on 'set zero'
  333.  * and is now properly scaled relative to the data magnitude.
  334.  *
  335.  * The key question in designing this function is the policy for just how
  336.  * much to widen the data range by, as a function of the data magnitude.
  337.  * This is to some extent a matter of taste.  IMHO the key criterion is
  338.  * that (at least) all of the following should (a) not infinite-loop, and
  339.  * (b) give correct plots, regardless of the 'set zero' setting:
  340.  *      plot 6.02e23            # a huge number >> 1 / FP roundoff level
  341.  *      plot 3                  # a "reasonable-sized" number
  342.  *      plot 1.23e-12           # a small number still > FP roundoff level
  343.  *      plot 1.23e-12 * sin(x)  # a small function still > FP roundoff level
  344.  *      plot 1.23e-45           # a tiny number << FP roundoff level
  345.  *      plot 1.23e-45 * sin(x)  # a tiny function << FP roundoff level
  346.  *      plot 0          # or (more commonly) a data file of all zeros
  347.  * That is, IMHO gnuplot should *never* infinite-loop, and it should *never*
  348.  * producing an incorrect or misleading plot.  In contrast, the old code
  349.  * would infinite-loop on most of these examples with 'set zero 0.0' in
  350.  * effect, or would plot the small-amplitude sine waves as the zero function
  351.  * with 'zero' set larger than the sine waves' amplitude.
  352.  *
  353.  * The current code plots all the above examples correctly and without
  354.  * infinite looping.
  355.  *
  356.  *
  357.  * === USAGE ===
  358.  *
  359.  * Arguments:
  360.  * axis = (in) An integer specifying which axis (x1, x2, y1, y2, z, etc)
  361.  *             we should do our stuff for.  We use this argument as an
  362.  *             index into the global arrays  {min,max,auto}_array .  In
  363.  *             practice this argument will typically be one of the constants
  364.  *              {FIRST,SECOND}_{X,Y,Z}_AXIS  defined in plot.h.
  365.  * axis_name --> (in) This argument should point to the character string
  366.  *                    name corresponding to  axis , e.g. "x", "y2", etc.
  367.  *                    We use this (only) in formatting warning/error messages.
  368.  *
  369.  * Global Variables:
  370.  * auto_array[axis] = (in) (defined in command.c) Bit-flags which tell
  371.  *                         [in some manner I don't fully understand :=( ]
  372.  *                         whether and/or how autoscaling is in effect for
  373.  *                         this axis.
  374.  * {min,max}_array = (in out) (defined in command.c) The data ranges which
  375.  *                            this function manipulates.
  376.  * c_token = (in) (defined in plot.h) Used in formatting an error message.
  377.  *
  378.  * Bugs:
  379.  * - If  strlen(axis_name) > strlen("%s") , we may overflow an
  380.  *   error-message buffer, which would be A Bad Thing.  Caveat caller...
  381.  */
  382. void fixup_range(axis, axis_name)
  383. int axis;
  384. char *axis_name;
  385. {
  386. #define MAX_AXIS_NAME_LEN    2    /* max legal strlen(axis_name) */
  387.  
  388. /* These two macro definitions set the range-widening policy: */
  389. #define FIXUP_RANGE__WIDEN_ZERO_ABS    1.0    /* widen [0:0] by
  390.                            +/- this absolute amount */
  391. #define FIXUP_RANGE__WIDEN_NONZERO_REL    0.01    /* widen [nonzero:nonzero] by
  392.                            -/+ this relative amount */
  393.  
  394.     double dmin = min_array[axis];
  395.     double dmax = max_array[axis];
  396.     if (dmax - dmin == 0.0) {
  397.     /* empty range */
  398.     if (auto_array[axis]) {
  399.         /* range came from autoscaling ==> widen it */
  400.         double widen = (dmax == 0.0)
  401.         ? FIXUP_RANGE__WIDEN_ZERO_ABS
  402.         : FIXUP_RANGE__WIDEN_NONZERO_REL * dmax;
  403.         fprintf(stderr,
  404.             "Warning: empty %s range [%g:%g], ",
  405.             axis_name, dmin, dmax);
  406.         min_array[axis] -= widen;
  407.         max_array[axis] += widen;
  408.         fprintf(stderr,
  409.             "adjusting to [%g:%g]\n",
  410.             min_array[axis], max_array[axis]);
  411.     } else {
  412.         /* user has explicitly set the range */
  413.         /* (to something empty) ==> we're in trouble */
  414.         char msg_buffer[MAX_LINE_LEN + 1];
  415.         sprintf(msg_buffer, "Can't plot with an empty %s range!", axis_name);
  416.         int_error(msg_buffer, c_token);    /* never returns */
  417.     }
  418.     }
  419. }
  420.  
  421. /*}}} */
  422.  
  423.  
  424. /*{{{  widest2d_callback() */
  425. /* we determine widest tick label by getting gen_ticks to call this
  426.  * routine with every label
  427.  */
  428.  
  429. static void widest2d_callback(axis, place, text, grid)
  430. int axis;
  431. double place;
  432. char *text;
  433. struct lp_style_type grid;
  434. {
  435.     int len = label_width(text, NULL);
  436.     if (len > widest_tic)
  437.     widest_tic = len;
  438. }
  439. /*}}} */
  440.  
  441.  
  442. /*{{{  boundary() */
  443. /* borders of plotting area
  444.  * computed once on every call to do_plot
  445.  *
  446.  * The order in which things is done is getting pretty critical:
  447.  *  ytop depends on title, x2label, ylabels (if no rotated text)
  448.  *  ybot depends on key, if TUNDER
  449.  *  once we have these, we can setup the y1 and y2 tics and the 
  450.  *  only then can we calculate xleft and xright
  451.  *  xright depends also on key TRIGHT
  452.  *  then we can do x and x2 tics
  453.  *
  454.  * For set size ratio ..., everything depends on everything else...
  455.  * not really a lot we can do about that, so we lose if the plot has to
  456.  * be reduced vertically. But the chances are the
  457.  * change will not be very big, so the number of tics will not
  458.  * change dramatically.
  459.  *
  460.  * Margin computation redone by Dick Crawford (rccrawford@lanl.gov) 4/98
  461.  */
  462.  
  463. static void boundary(scaling, plots, count)
  464. TBOOLEAN scaling;        /* TRUE if terminal is doing the scaling */
  465. struct curve_points *plots;
  466. int count;
  467. {
  468.     int ytlen;
  469.     int yticlin = 0, y2ticlin = 0, timelin = 0;
  470.  
  471.     register struct termentry *t = term;
  472.     int key_h, key_w;
  473.     int can_rotate = (*t->text_angle) (1);
  474.  
  475.     int xtic_textheight;    /* height of xtic labels */
  476.     int x2tic_textheight;    /* height of x2tic labels */
  477.     int title_textheight;    /* height of title */
  478.     int xlabel_textheight;    /* height of xlabel */
  479.     int x2label_textheight;    /* height of x2label */
  480.     int timetop_textheight;    /* height of timestamp (if at top) */
  481.     int timebot_textheight;    /* height of timestamp (if at bottom) */
  482.     int ylabel_textheight;    /* height of (unrotated) ylabel */
  483.     int y2label_textheight;    /* height of (unrotated) y2label */
  484.     int ylabel_textwidth;    /* width of (rotated) ylabel */
  485.     int y2label_textwidth;    /* width of (rotated) y2label */
  486.     int timelabel_textwidth;    /* width of timestamp */
  487.     int ytic_textwidth;        /* width of ytic labels */
  488.     int y2tic_textwidth;    /* width of y2tic labels */
  489.     int x2tic_height;        /* 0 for tic_in or no x2tics, ticscale*v_tic otherwise */
  490.     int xtic_height;
  491.     int ytic_width;
  492.     int y2tic_width;
  493.  
  494.     /* figure out which rotatable items are to be rotated
  495.      * (ylabel and y2label are rotated if possible) */
  496.     int vertical_timelabel = can_rotate && timelabel_rotate;
  497.     int vertical_xtics = can_rotate && rotate_xtics;
  498.     int vertical_x2tics = can_rotate && rotate_x2tics;
  499.     int vertical_ytics = can_rotate && rotate_ytics;
  500.     int vertical_y2tics = can_rotate && rotate_y2tics;
  501.  
  502.     lkey = key;            /* but we may have to disable it later */
  503.  
  504.     xticlin = ylablin = y2lablin = xlablin = x2lablin = titlelin = 0;
  505.  
  506.     /*{{{  count lines in labels and tics */
  507.     if (*title.text)
  508.     label_width(title.text, &titlelin);
  509.     if (*xlabel.text)
  510.     label_width(xlabel.text, &xlablin);
  511.     if (*x2label.text)
  512.     label_width(x2label.text, &x2lablin);
  513.     if (*ylabel.text)
  514.     label_width(ylabel.text, &ylablin);
  515.     if (*y2label.text)
  516.     label_width(y2label.text, &y2lablin);
  517.     if (xtics)
  518.     label_width(xformat, &xticlin);
  519.     if (x2tics)
  520.     label_width(x2format, &x2ticlin);
  521.     if (ytics)
  522.     label_width(yformat, &yticlin);
  523.     if (y2tics)
  524.     label_width(y2format, &y2ticlin);
  525.     if (*timelabel.text)
  526.     label_width(timelabel.text, &timelin);
  527.     /*}}} */
  528.  
  529.     /*{{{  preliminary ytop  calculation */
  530.  
  531.     /*     first compute heights of things to be written in the margin */
  532.  
  533.     /* title */
  534.     if (titlelin)
  535.     title_textheight = (int) ((titlelin + title.yoffset + 1) * (t->v_char));
  536.     else
  537.     title_textheight = 0;
  538.  
  539.     /* x2label */
  540.     if (x2lablin) {
  541.     x2label_textheight = (int) ((x2lablin + x2label.yoffset) * (t->v_char));
  542.     if (!x2tics)
  543.         x2label_textheight += 0.5 * t->v_char;
  544.     } else
  545.     x2label_textheight = 0;
  546.  
  547.     /* tic labels */
  548.     if (x2tics & TICS_ON_BORDER) {
  549.     /* ought to consider tics on axes if axis near border */
  550.     if (vertical_x2tics) {
  551.         /* guess at tic length, since we don't know it yet
  552.            --- we'll fix it after the tic labels have been created */
  553.         x2tic_textheight = (int) (5 * (t->h_char));
  554.     } else
  555.         x2tic_textheight = (int) ((x2ticlin) * (t->v_char));
  556.     } else
  557.     x2tic_textheight = 0;
  558.  
  559.     /* tics */
  560.     if (!tic_in && ((x2tics & TICS_ON_BORDER) || ((xtics & TICS_MIRROR) && (xtics & TICS_ON_BORDER))))
  561.     x2tic_height = (int) ((t->v_tic) * ticscale);
  562.     else
  563.     x2tic_height = 0;
  564.  
  565.     /* timestamp */
  566.     if (*timelabel.text && !timelabel_bottom)
  567.     timetop_textheight = (int) ((timelin + timelabel.yoffset + 2) * (t->v_char));
  568.     else
  569.     timetop_textheight = 0;
  570.  
  571.     /* horizontal ylabel */
  572.     if (*ylabel.text && !can_rotate)
  573.     ylabel_textheight = (int) ((ylablin + ylabel.yoffset) * (t->v_char));
  574.     else
  575.     ylabel_textheight = 0;
  576.  
  577.     /* horizontal y2label */
  578.     if (*y2label.text && !can_rotate)
  579.     y2label_textheight = (int) ((y2lablin + y2label.yoffset) * (t->v_char));
  580.     else
  581.     y2label_textheight = 0;
  582.  
  583.     /* compute ytop from the various components
  584.      *     unless tmargin is explicitly specified  */
  585.  
  586.     ytop = (int) ((ysize + yoffset) * (t->ymax));
  587.  
  588.     if (tmargin < 0) {
  589.     int top_margin = x2label_textheight + title_textheight;
  590.     if (timetop_textheight + ylabel_textheight > top_margin)
  591.         top_margin = timetop_textheight + ylabel_textheight;
  592.     if (y2label_textheight > top_margin)
  593.         top_margin = y2label_textheight;
  594.  
  595.     top_margin += x2tic_height + x2tic_textheight;
  596. /* FIXME: what is this additional space reservation for??? */
  597.     if (top_margin > x2tic_height)
  598.         top_margin += (int) (t->v_char);
  599.  
  600.     ytop -= top_margin;
  601.     if (ytop == (int) ((ysize + yoffset) * (t->ymax))) {
  602.         /* make room for the end of rotated ytics or y2tics */
  603.         ytop -= (int) ((t->h_char) * 2);
  604.     }
  605.     } else
  606.     ytop -= (int) ((t->v_char) * tmargin);
  607.  
  608.     /*  end of preliminary ytop calculation }}} */
  609.  
  610.  
  611.     /*{{{  tentative xleft, needed for TUNDER */
  612.     if (lmargin >= 0)
  613.     xleft = (int) (xoffset * (t->xmax) + (t->h_char) * lmargin);
  614.     else
  615.     xleft = (int) (xoffset * (t->xmax) + (t->h_char) * 2);
  616.     /*}}} */
  617.  
  618.  
  619.     /*{{{  tentative xright, needed for TUNDER */
  620.     if (rmargin >= 0)
  621.     xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * rmargin);
  622.     else
  623.     xright = (int) ((xsize + xoffset) * (t->xmax) - (t->h_char) * 2);
  624.     /*}}} */
  625.  
  626.  
  627.     /*{{{  preliminary ybot calculation
  628.      *     first compute heights of labels and tics */
  629.  
  630.     /* tic labels */
  631.     if (xtics & TICS_ON_BORDER) {
  632.     /* ought to consider tics on axes if axis near border */
  633.     if (vertical_xtics) {
  634.         /* guess at tic length, since we don't know it yet */
  635.         xtic_textheight = (int) ((t->h_char) * 5);
  636.     } else
  637.         xtic_textheight = (int) ((t->v_char) * (xticlin + 1));
  638.     } else
  639.     xtic_textheight = 0;
  640.  
  641.     /* tics */
  642.     if (!tic_in && ((xtics & TICS_ON_BORDER) || ((x2tics & TICS_MIRROR) && (x2tics & TICS_ON_BORDER))))
  643.     xtic_height = (int) ((t->v_tic) * ticscale);
  644.     else
  645.     xtic_height = 0;
  646.  
  647.     /* xlabel */
  648.     if (xlablin) {
  649.     /* offset is subtracted because if . 0, the margin is smaller */
  650.     xlabel_textheight = (int) ((xlablin - xlabel.yoffset) * (t->v_char));
  651.     if (!xtics)
  652.         xlabel_textheight += 0.5 * t->v_char;
  653.     } else
  654.     xlabel_textheight = 0;
  655.  
  656.     /* timestamp */
  657.     if (*timelabel.text && timelabel_bottom) {
  658.     /* && !vertical_timelabel)
  659.      * DBT 11-18-98 resize plot for vertical timelabels too !
  660.      */
  661.     /* offset is subtracted because if . 0, the margin is smaller */
  662.     timebot_textheight = (int) ((timelin - timelabel.yoffset + 1.5) * (t->v_char));
  663.     }
  664.     else
  665.     timebot_textheight = 0;
  666.  
  667.     /* compute ybot from the various components
  668.      *     unless bmargin is explicitly specified  */
  669.  
  670.     ybot = (int) ((t->ymax) * yoffset);
  671.  
  672.     if (bmargin < 0) {
  673.     ybot += xtic_height + xtic_textheight;
  674.     if (timebot_textheight > 0 || xlabel_textheight > 0)
  675.         ybot += (timebot_textheight > xlabel_textheight) ? timebot_textheight : xlabel_textheight;
  676.     if (ybot == (t->ymax) * yoffset) {
  677.         /* make room for the end of rotated ytics or y2tics */
  678.         ybot += (int) ((t->h_char) * 2);
  679.     }
  680.     } else
  681.     ybot += (int) (bmargin * (t->v_char));
  682.  
  683.     /*  end of preliminary ybot calculation }}} */
  684.  
  685.  
  686. #define KEY_PANIC(x) if (x) { lkey = 0; goto key_escape; }
  687.  
  688.     if (lkey) {
  689.     /*{{{  essential key features */
  690.     p_width = pointsize * t->h_tic;
  691.     p_height = pointsize * t->v_tic;
  692.  
  693.     if (key_swidth >= 0)
  694.         key_sample_width = key_swidth * (t->h_char) + p_width;
  695.     else
  696.         key_sample_width = 0;
  697.  
  698.     key_entry_height = p_height * 1.25 * key_vert_factor;
  699.     if (key_entry_height < (t->v_char))
  700.         key_entry_height = (t->v_char) * key_vert_factor;
  701.  
  702.     /* count max_len key and number keys with len > 0 */
  703.     max_ptitl_len = find_maxl_keys(plots, count, &ptitl_cnt);
  704.     if ((ytlen = label_width(key_title, &ktitl_lines)) > max_ptitl_len)
  705.         max_ptitl_len = ytlen;
  706.  
  707.     if (key_reverse) {
  708.         key_sample_left = -key_sample_width;
  709.         key_sample_right = 0;
  710.         /* if key width is being used, adjust right-justified text */
  711.         key_text_left = t->h_char;
  712.         key_text_right = (t->h_char) * (max_ptitl_len + 1 + key_width_fix);
  713.         key_size_left = t->h_char - key_sample_left;    /* sample left is -ve */
  714.         key_size_right = key_text_right;
  715.     } else {
  716.         key_sample_left = 0;
  717.         key_sample_right = key_sample_width;
  718.         /* if key width is being used, adjust left-justified text */
  719.         key_text_left = -(int) ((t->h_char) * (max_ptitl_len + 1 + key_width_fix));
  720.         key_text_right = -(int) (t->h_char);
  721.         key_size_left = -key_text_left;
  722.         key_size_right = key_sample_right + t->h_char;
  723.     }
  724.     key_point_offset = (key_sample_left + key_sample_right) / 2;
  725.  
  726.     /* advance width for cols */
  727.     key_col_wth = key_size_left + key_size_right;
  728.  
  729.     key_rows = ptitl_cnt;
  730.     key_cols = 1;
  731.  
  732.     /* calculate rows and cols for key - if something goes wrong,
  733.      * the tidiest way out is to  set lkey = 0, and a goto
  734.      */
  735.  
  736.     if (lkey == -1) {
  737.         if (key_vpos == TUNDER) {
  738.         /* maximise no cols, limited by label-length */
  739.         key_cols = (int) (xright - xleft) / key_col_wth;
  740.         KEY_PANIC(key_cols == 0);
  741.         key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
  742.         KEY_PANIC(key_rows == 0);
  743.         /* now calculate actual no cols depending on no rows */
  744.         key_cols = (int) (ptitl_cnt + key_rows - 1) / key_rows;
  745.         KEY_PANIC(key_cols == 0);
  746.         key_col_wth = (int) (xright - xleft) / key_cols;
  747.         /* we divide into columns, then centre in column by considering
  748.          * ratio of * key_left_size to key_right_size
  749.          *
  750.          * key_size_left/(key_size_left+key_size_right) * (xright-xleft)/key_cols
  751.          * do one integer division to maximise accuracy (hope we
  752.          * don't overflow !)
  753.          */
  754.         key_xl = xleft - key_size_left + ((xright - xleft) * key_size_left) / (key_cols * (key_size_left + key_size_right));
  755.         key_xr = key_xl + key_col_wth * (key_cols - 1) + key_size_left + key_size_right;
  756.         key_yb = t->ymax * yoffset;
  757.         key_yt = key_yb + key_rows * key_entry_height + ktitl_lines * t->v_char;
  758.         ybot += key_entry_height * key_rows + (int) ((t->v_char) * (ktitl_lines + 1));
  759.         } else {
  760.         /* maximise no rows, limited by ytop-ybot */
  761.         int i = (int) (ytop - ybot - (ktitl_lines + 1) * (t->v_char)) / key_entry_height;
  762.         KEY_PANIC(i == 0);
  763.         if (ptitl_cnt > i) {
  764.             key_cols = (int) (ptitl_cnt + i - 1) / i;
  765.             /* now calculate actual no rows depending on no cols */
  766.             KEY_PANIC(key_cols == 0);
  767.             key_rows = (int) (ptitl_cnt + key_cols - 1) / key_cols;
  768.         }
  769.         }
  770.         /* come here if we detect a division by zero in key calculations */
  771.       key_escape:
  772.         ;            /* ansi requires this */
  773.     }
  774.     /*}}} */
  775.     }
  776.     /*{{{  set up y and y2 tics */
  777.     {
  778.     /* setup_tics allows max number of tics to be specified
  779.      * but users dont like it to change with size and font,
  780.      * so we use value of 20, which is 3.5 behaviour.
  781.      * Note also that if format is '', yticlin = 0, so this gives
  782.      * division by zero. 
  783.      * int guide = (ytop-ybot)/term->v_char;
  784.      */
  785.     if (ytics)
  786.         setup_tics(FIRST_Y_AXIS, &yticdef, yformat, 20 /*(int) (guide/yticlin) */ );
  787.     if (y2tics)
  788.         setup_tics(SECOND_Y_AXIS, &y2ticdef, y2format, 20 /*(int) (guide/y2ticlin) */ );
  789.     }
  790.     /*}}} */
  791.  
  792.  
  793.     /*{{{  recompute xleft based on widths of ytics, ylabel etc
  794.        unless it has been explicitly set by lmargin */
  795.  
  796.     /* tic labels */
  797.     if (ytics & TICS_ON_BORDER) {
  798.     if (vertical_ytics)
  799.         /* HBB: we will later add some white space as part of this, so
  800.          * reserve two more rows (one above, one below the text ...).
  801.          * Same will be done to similar calc.'s elsewhere */
  802.         ytic_textwidth = (int) ((t->v_char) * (yticlin + 2));
  803.     else {
  804.         widest_tic = 0;    /* reset the global variable ... */
  805.         /* get gen_tics to call widest2d_callback with all labels
  806.          * the latter sets widest_tic to the length of the widest one
  807.          * ought to consider tics on axis if axis near border...
  808.          */
  809.         gen_tics(FIRST_Y_AXIS, &yticdef, 0, 0, 0.0, widest2d_callback);
  810.  
  811.         ytic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
  812.     }
  813.     } else {
  814.     ytic_textwidth = 0;
  815.     }
  816.  
  817.     /* tics */
  818.     if (!tic_in && ((ytics & TICS_ON_BORDER) || ((y2tics & TICS_MIRROR) && (y2tics & TICS_ON_BORDER))))
  819.     ytic_width = (int) ((t->h_tic) * ticscale);
  820.     else
  821.     ytic_width = 0;
  822.  
  823.     /* ylabel */
  824.     if (*ylabel.text && can_rotate) {
  825.     ylabel_textwidth = (int) ((ylablin - ylabel.xoffset) * (t->v_char));
  826.     if (!ytics)
  827.         ylabel_textwidth += 0.5 * t->v_char;
  828.     }
  829.     /* this should get large for NEGATIVE ylabel.xoffsets  DBT 11-5-98 */
  830.     else
  831.     ylabel_textwidth = 0;
  832.  
  833.     /* timestamp */
  834.     if (*timelabel.text && vertical_timelabel)
  835.     timelabel_textwidth = (int) ((timelin - timelabel.xoffset + 1.5) * (t->v_char));
  836.     else
  837.     timelabel_textwidth = 0;
  838.  
  839.     /* compute xleft from the various components
  840.      *     unless lmargin is explicitly specified  */
  841.  
  842.     xleft = (int) ((t->xmax) * xoffset);
  843.  
  844.     if (lmargin < 0) {
  845.     xleft += (timelabel_textwidth > ylabel_textwidth ? timelabel_textwidth : ylabel_textwidth)
  846.         + ytic_width + ytic_textwidth;
  847.  
  848.     if (xleft == (t->xmax) * xoffset) {
  849.         /* make room for end of xtic or x2tic label */
  850.         xleft += (int) ((t->h_char) * 2);
  851.     }
  852.     /* DBT 12-3-98  extra margin just in case */
  853.     xleft += 0.5 * t->v_char;
  854.     } else
  855.     xleft += (int) (lmargin * (t->h_char));
  856.  
  857.     /* make sure xleft is wide enough for a negatively
  858.      * x-offset horizontal timestamp
  859.      */
  860.     if (!vertical_timelabel && xleft - ytic_width - ytic_textwidth < -(int) (timelabel.xoffset * (t->h_char)))
  861.     xleft = ytic_width + ytic_textwidth - (int) (timelabel.xoffset * (t->h_char));
  862.     /*  end of xleft calculation }}} */
  863.  
  864.  
  865.     /*{{{  recompute xright based on widest y2tic. y2labels, key TOUT
  866.        unless it has been explicitly set by rmargin */
  867.  
  868.     /* tic labels */
  869.     if (y2tics & TICS_ON_BORDER) {
  870.     if (vertical_y2tics)
  871.         y2tic_textwidth = (int) ((t->v_char) * (y2ticlin + 2));
  872.     else {
  873.         widest_tic = 0;    /* reset the global variable ... */
  874.         /* get gen_tics to call widest2d_callback with all labels
  875.          * the latter sets widest_tic to the length of the widest one
  876.          * ought to consider tics on axis if axis near border...
  877.          */
  878.         gen_tics(SECOND_Y_AXIS, &y2ticdef, 0, 0, 0.0, widest2d_callback);
  879.  
  880.         y2tic_textwidth = (int) ((t->h_char) * (widest_tic + 2));
  881.     }
  882.     } else {
  883.     y2tic_textwidth = 0;
  884.     }
  885.  
  886.     /* tics */
  887.     if (!tic_in && ((y2tics & TICS_ON_BORDER) || ((ytics & TICS_MIRROR) && (ytics & TICS_ON_BORDER))))
  888.     y2tic_width = (int) ((t->h_tic) * ticscale);
  889.     else
  890.     y2tic_width = 0;
  891.  
  892.     /* y2label */
  893.     if (can_rotate && *y2label.text) {
  894.     y2label_textwidth = (int) ((y2lablin + y2label.xoffset) * (t->v_char));
  895.     if (!y2tics)
  896.         y2label_textwidth += 0.5 * t->v_char;
  897.     } else
  898.     y2label_textwidth = 0;
  899.  
  900.     /* compute xright from the various components
  901.      *     unless rmargin is explicitly specified  */
  902.  
  903.     xright = (int) ((t->xmax) * (xsize + xoffset));
  904.  
  905.     if (rmargin < 0) {
  906.     /* xright -= y2label_textwidth + y2tic_width + y2tic_textwidth; */
  907.     xright -= y2tic_width + y2tic_textwidth;
  908.     if (y2label_textwidth > 0)
  909.         xright -= y2label_textwidth;
  910.  
  911.     /* adjust for outside key */
  912.     if (lkey == -1 && key_hpos == TOUT) {
  913.         xright -= key_col_wth * key_cols;
  914.         key_xl = xright + (int) (t->h_tic);
  915.     }
  916.     if (xright == (t->xmax) * (xsize + xoffset)) {
  917.         /* make room for end of xtic or x2tic label */
  918.         xright -= (int) ((t->h_char) * 2);
  919.     }
  920.     xright -= 0.5 * t->v_char;    /* DBT 12-3-98  extra margin just in case */
  921.  
  922.     } else
  923.     xright -= (int) (rmargin * (t->h_char));
  924.  
  925.     /*  end of xright calculation }}} */
  926.  
  927.  
  928.     if (aspect_ratio != 0.0) {
  929.     double current_aspect_ratio;
  930.  
  931.     if (aspect_ratio < 0 && (max_array[x_axis] - min_array[x_axis]) != 0.0) {
  932.         current_aspect_ratio = -aspect_ratio * (max_array[y_axis] - min_array[y_axis]) / (max_array[x_axis] - min_array[x_axis]);
  933.     } else
  934.         current_aspect_ratio = aspect_ratio;
  935.  
  936.     /*{{{  set aspect ratio if valid and sensible */
  937.     if (current_aspect_ratio >= 0.01 && current_aspect_ratio <= 100.0) {
  938.         double current = ((double) (ytop - ybot)) / ((double) (xright - xleft));
  939.         double required = (current_aspect_ratio * (double) t->v_tic) / ((double) t->h_tic);
  940.  
  941.         if (current > required) {
  942.         /* too tall */
  943.         ytop = ybot + required * (xright - xleft);
  944.         } else {
  945.         /* HBB: y2label_x wasn't defined yet, and would be
  946.          * overwritten later */
  947.         xright = xleft + (ytop - ybot) / required;
  948.         }
  949.     }
  950.     /*}}} */
  951.     }
  952.     /*{{{  set up x and x2 tics */
  953.     /* we should base the guide on the width of the xtics, but we cannot
  954.      * use widest_tics until tics are set up. Bit of a downer - let us
  955.      * assume tics are 5 characters wide
  956.      */
  957.  
  958.     {
  959.     /* see equivalent code for ytics above
  960.      * int guide = (xright - xleft) / (5*t->h_char);
  961.      */
  962.  
  963.     if (xtics)
  964.         setup_tics(FIRST_X_AXIS, &xticdef, xformat, 20 /*guide */ );
  965.     if (x2tics)
  966.         setup_tics(SECOND_X_AXIS, &x2ticdef, x2format, 20 /*guide */ );
  967.     }
  968.     /*}}} */
  969.  
  970.  
  971.     /*  adjust top and bottom margins for tic label rotation */
  972.  
  973.     if (tmargin < 0 && x2tics & TICS_ON_BORDER && vertical_x2tics) {
  974.     widest_tic = 0;        /* reset the global variable ... */
  975.     gen_tics(SECOND_X_AXIS, &x2ticdef, 0, 0, 0.0, widest2d_callback);
  976. /* HBB: redid this: remove rough guess value first. Among other reasons,
  977.  * I suspected the '-4 lines' of the original code to be in error, as the
  978.  * original calc. of x2tic_textheight uses *5* lines */
  979.     ytop += x2tic_textheight;
  980. /* Now compute a new one and use that instead: */
  981.     x2tic_textheight = (int) ((t->h_char) * (widest_tic));
  982.     ytop -= x2tic_textheight;
  983.     }
  984.     if (bmargin < 0 && xtics & TICS_ON_BORDER && vertical_xtics) {
  985.     widest_tic = 0;        /* reset the global variable ... */
  986.     gen_tics(FIRST_X_AXIS, &xticdef, 0, 0, 0.0, widest2d_callback);
  987. /* HBB: same changes as for tmargin/ytop above */
  988.     ybot -= xtic_textheight;
  989.     xtic_textheight = (int) ((t->h_char) * widest_tic);
  990.     ybot += xtic_textheight;
  991.     }
  992.     /*  compute coordinates for axis labels, title et al
  993.      *     (some of these may not be used) */
  994.  
  995.     x2label_y = ytop + x2tic_height + x2tic_textheight + x2label_textheight;
  996.     if (x2tic_textheight && (title_textheight || x2label_textheight))
  997.     x2label_y += t->v_char;
  998.  
  999.     title_y = x2label_y + title_textheight;
  1000.  
  1001.     ylabel_y = ytop + x2tic_height + x2tic_textheight + ylabel_textheight;
  1002.  
  1003.     y2label_y = ytop + x2tic_height + x2tic_textheight + y2label_textheight;
  1004.  
  1005.     xlabel_y = ybot - xtic_height - xtic_textheight - xlabel_textheight + t->v_char;
  1006.     ylabel_x = xleft - ytic_width - ytic_textwidth;
  1007.     if (*ylabel.text && can_rotate)
  1008.     ylabel_x -= ylabel_textwidth;
  1009.  
  1010.     y2label_x = xright + y2tic_width + y2tic_textwidth;
  1011.     if (*y2label.text && can_rotate)
  1012.     y2label_x += y2label_textwidth - t->v_char;
  1013.  
  1014.     if (vertical_timelabel) {
  1015.     if (timelabel_bottom)
  1016.         time_y = xlabel_y - timebot_textheight + xlabel_textheight;
  1017.     else {
  1018.         time_y = title_y + timetop_textheight - title_textheight - x2label_textheight;
  1019.     }
  1020.     } else {
  1021.     if (timelabel_bottom)
  1022.         time_y = xlabel_y - timebot_textheight + xlabel_textheight;
  1023.     else if (ylabel_textheight > 0)
  1024.         time_y = ylabel_y + timetop_textheight;
  1025.     else
  1026.         time_y = ytop + x2tic_height + x2tic_textheight + timetop_textheight + (int) (t->h_char);
  1027.     }
  1028.     if (vertical_timelabel)
  1029.     time_x = xleft - ytic_width - ytic_textwidth - timelabel_textwidth;
  1030.     else
  1031.     time_x = xleft - ytic_width - ytic_textwidth + (int) (timelabel.xoffset * (t->h_char));
  1032.  
  1033.     xtic_y = ybot - xtic_height - (vertical_xtics ? (int) (t->h_char) : (int) (t->v_char));
  1034.  
  1035.     x2tic_y = ytop + x2tic_height + (vertical_x2tics ? (int) (t->h_char) : x2tic_textheight);
  1036.  
  1037.     ytic_x = xleft - ytic_width - (vertical_ytics ? (ytic_textwidth - (int) t->v_char) : (int) (t->h_char));
  1038.  
  1039.     y2tic_x = xright + y2tic_width + (vertical_y2tics ? (int) (t->v_char) : (int) (t->h_char));
  1040.  
  1041.     /* restore text to horizontal [we tested rotation above] */
  1042.     (void) (*t->text_angle) (0);
  1043.  
  1044.     /* needed for map_position() below */
  1045.  
  1046.     scale[FIRST_Y_AXIS] = (ytop - ybot) / (max_array[FIRST_Y_AXIS] - min_array[FIRST_Y_AXIS]);
  1047.     scale[FIRST_X_AXIS] = (xright - xleft) / (max_array[FIRST_X_AXIS] - min_array[FIRST_X_AXIS]);
  1048.     scale[SECOND_Y_AXIS] = (ytop - ybot) / (max_array[SECOND_Y_AXIS] - min_array[SECOND_Y_AXIS]);
  1049.     scale[SECOND_X_AXIS] = (xright - xleft) / (max_array[SECOND_X_AXIS] - min_array[SECOND_X_AXIS]);
  1050.  
  1051.     /*{{{  calculate the window in the grid for the key */
  1052.     if (lkey == 1 || (lkey == -1 && key_vpos != TUNDER)) {
  1053.     /* calculate space for keys to prevent grid overwrite the keys */
  1054.     /* do it even if there is no grid, as do_plot will use these to position key */
  1055.     key_w = key_col_wth * key_cols;
  1056.     key_h = (ktitl_lines) * t->v_char + key_rows * key_entry_height;
  1057.     if (lkey == -1) {
  1058.         if (key_vpos == TTOP) {
  1059.         key_yt = (int) ytop - (t->v_tic);
  1060.         key_yb = key_yt - key_h;
  1061.         } else {
  1062.         key_yb = ybot + (t->v_tic);
  1063.         key_yt = key_yb + key_h;
  1064.         }
  1065.         if (key_hpos == TLEFT) {
  1066.         key_xl = xleft + (t->h_char);    /* for Left just */
  1067.         key_xr = key_xl + key_w;
  1068.         } else if (key_hpos == TRIGHT) {
  1069.         key_xr = xright - (t->h_char);    /* for Right just */
  1070.         key_xl = key_xr - key_w;
  1071.         } else {        /* TOUT */
  1072.         /* do this here for do_plot() */
  1073.         /* align right first since rmargin may be manual */
  1074.         key_xr = (xsize + xoffset) * (t->xmax) - (t->h_char);
  1075.         key_xl = key_xr - key_w;
  1076.         }
  1077.     } else {
  1078.         unsigned int x, y;
  1079.         map_position(&key_user_pos, &x, &y, "key");
  1080.         key_xl = x - key_size_left;
  1081.         key_xr = key_xl + key_w;
  1082.         key_yt = y + (ktitl_lines ? t->v_char : key_entry_height) / 2;
  1083.         key_yb = key_yt - key_h;
  1084.     }
  1085.     }
  1086.     /*}}} */
  1087.  
  1088. }
  1089.  
  1090. /*}}} */
  1091.  
  1092. /*{{{  dbl_raise() */
  1093. static double dbl_raise(x, y)
  1094. double x;
  1095. int y;
  1096. {
  1097.     register int i = abs(y);
  1098.     double val = 1.0;
  1099.  
  1100.     while (--i >= 0)
  1101.     val *= x;
  1102.  
  1103.     if (y < 0)
  1104.     return (1.0 / val);
  1105.     return (val);
  1106. }
  1107. /*}}} */
  1108.  
  1109. /*{{{  timetic_fmt() */
  1110. void timetic_format(axis, amin, amax)
  1111. int axis;
  1112. double amin, amax;
  1113. {
  1114.     struct tm tmin, tmax;
  1115.  
  1116.     *ticfmt[axis] = 0;        /* make sure we strcat to empty string */
  1117.  
  1118.     ggmtime(&tmin, (double) time_tic_just(timelevel[axis], amin));
  1119.     ggmtime(&tmax, (double) time_tic_just(timelevel[axis], amax));
  1120.     /*
  1121.        if ( tmax.tm_year == tmin.tm_year && 
  1122.        tmax.tm_mon == tmin.tm_mon && 
  1123.        tmax.tm_mday == tmin.tm_mday ) {
  1124.      */
  1125.     if (tmax.tm_year == tmin.tm_year &&
  1126.     tmax.tm_yday == tmin.tm_yday) {
  1127.     /* same day, skip date */
  1128.     if (tmax.tm_hour != tmin.tm_hour) {
  1129.         strcpy(ticfmt[axis], "%H");
  1130.     }
  1131.     if (timelevel[axis] < 3) {
  1132.         if (strlen(ticfmt[axis]))
  1133.         strcat(ticfmt[axis], ":");
  1134.         strcat(ticfmt[axis], "%M");
  1135.     }
  1136.     if (timelevel[axis] < 2) {
  1137.         strcat(ticfmt[axis], ":%S");
  1138.     }
  1139.     } else {
  1140.     if (tmax.tm_year != tmin.tm_year) {
  1141.         /* different years, include year in ticlabel */
  1142.         /* check convention, day/month or month/day */
  1143.         if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
  1144.         strcpy(ticfmt[axis], "%m/%d/%");
  1145.         } else {
  1146.         strcpy(ticfmt[axis], "%d/%m/%");
  1147.         }
  1148.         if (((int) (tmax.tm_year / 100)) != ((int) (tmin.tm_year / 100))) {
  1149.         strcat(ticfmt[axis], "Y");
  1150.         } else {
  1151.         strcat(ticfmt[axis], "y");
  1152.         }
  1153.  
  1154.     } else {
  1155.         if (strchr(timefmt, 'm') < strchr(timefmt, 'd')) {
  1156.         strcpy(ticfmt[axis], "%m/%d");
  1157.         } else {
  1158.         strcpy(ticfmt[axis], "%d/%m");
  1159.         }
  1160.     }
  1161.     if (timelevel[axis] < 4) {
  1162.         strcat(ticfmt[axis], "\n%H:%M");
  1163.     }
  1164.     }
  1165. }
  1166. /*}}} */
  1167.  
  1168. /*{{{  set_tic() */
  1169. /* the guide parameter was intended to allow the number of tics
  1170.  * to depend on the relative sizes of the plot and the font.
  1171.  * It is the approximate upper limit on number of tics allowed.
  1172.  * But it did not go down well with the users.
  1173.  * A value of 20 gives the same behaviour as 3.5, so that is
  1174.  * hardwired into the calls to here. Maybe we will restore it
  1175.  * to the automatic calculation one day
  1176.  */
  1177.  
  1178. double set_tic(l10, guide)
  1179. double l10;
  1180. int guide;
  1181. {
  1182.     double xnorm, tics, posns;
  1183.  
  1184.     int fl = (int) floor(l10);
  1185.     xnorm = pow(10.0, l10 - fl);    /* approx number of decades */
  1186.  
  1187.     posns = guide / xnorm;    /* approx number of tic posns per decade */
  1188.  
  1189.     if (posns > 40)
  1190.     tics = 0.05;        /* eg 0, .05, .10, ... */
  1191.     else if (posns > 20)
  1192.     tics = 0.1;        /* eg 0, .1, .2, ... */
  1193.     else if (posns > 10)
  1194.     tics = 0.2;        /* eg 0,0.2,0.4,... */
  1195.     else if (posns > 4)
  1196.     tics = 0.5;        /* 0,0.5,1, */
  1197.     else if (posns > 1)
  1198.     tics = 1;        /* 0,1,2,.... */
  1199.     else if (posns > 0.5)
  1200.     tics = 2;        /* 0, 2, 4, 6 */
  1201.     else
  1202.     /* getting desperate... the ceil is to make sure we
  1203.      * go over rather than under - eg plot [-10:10] x*x
  1204.      * gives a range of about 99.999 - tics=xnorm gives
  1205.      * tics at 0, 99.99 and 109.98  - BAD !
  1206.      * This way, inaccuracy the other way will round
  1207.      * up (eg 0->100.0001 => tics at 0 and 101
  1208.      * I think latter is better than former
  1209.      */
  1210.     tics = ceil(xnorm);
  1211.  
  1212.     return (tics * dbl_raise(10.0, fl));
  1213. }
  1214. /*}}} */
  1215.  
  1216. /*{{{  make_tics() */
  1217. static double make_tics(axis, guide)
  1218. int axis, guide;
  1219. {
  1220.     register double xr, tic, l10;
  1221.  
  1222.     xr = fabs(min_array[axis] - max_array[axis]);
  1223.  
  1224.     l10 = log10(xr);
  1225.     tic = set_tic(l10, guide);
  1226.     if (log_array[axis] && tic < 1.0)
  1227.     tic = 1.0;
  1228.     if (datatype[axis] == TIME) {
  1229.     struct tm ftm, etm;
  1230.     /* this is not fun */
  1231.     ggmtime(&ftm, (double) min_array[axis]);
  1232.     ggmtime(&etm, (double) max_array[axis]);
  1233.  
  1234.     timelevel[axis] = 0;    /* seconds */
  1235.     if (tic > 20) {
  1236.         /* turn tic into units of minutes */
  1237.         tic = set_tic(log10(xr / 60.0), guide) * 60;
  1238.         timelevel[axis] = 1;    /* minutes */
  1239.     }
  1240.     if (tic > 20 * 60) {
  1241.         /* turn tic into units of hours */
  1242.         tic = set_tic(log10(xr / 3600.0), guide) * 3600;
  1243.         timelevel[axis] = 2;    /* hours */
  1244.     }
  1245.     if (tic > 2 * 3600) {
  1246.         /* need some tickling */
  1247.         tic = set_tic(log10(xr / (3 * 3600.0)), guide) * 3 * 3600;
  1248.     }
  1249.     if (tic > 6 * 3600) {
  1250.         /* turn tic into units of days */
  1251.         tic = set_tic(log10(xr / DAY_SEC), guide) * DAY_SEC;
  1252.         timelevel[axis] = 3;    /* days */
  1253.     }
  1254.     if (tic > 3 * DAY_SEC) {
  1255.         /* turn tic into units of weeks */
  1256.         tic = set_tic(log10(xr / WEEK_SEC), guide) * WEEK_SEC;
  1257.         if (tic < WEEK_SEC) {    /* force */
  1258.         tic = WEEK_SEC;
  1259.         }
  1260.         timelevel[axis] = 4;    /* weeks */
  1261.     }
  1262.     if (tic > 3 * WEEK_SEC) {
  1263.         /* turn tic into units of month */
  1264.         tic = set_tic(log10(xr / MON_SEC), guide) * MON_SEC;
  1265.         if (tic < MON_SEC) {    /* force */
  1266.         tic = MON_SEC;
  1267.         }
  1268.         timelevel[axis] = 5;    /* month */
  1269.     }
  1270.     if (tic > 2 * MON_SEC) {
  1271.         /* turn tic into units of month */
  1272.         tic = set_tic(log10(xr / (3 * MON_SEC)), guide) * 3 * MON_SEC;
  1273.     }
  1274.     if (tic > 6 * MON_SEC) {
  1275.         /* turn tic into units of years */
  1276.         tic = set_tic(log10(xr / YEAR_SEC), guide) * YEAR_SEC;
  1277.         if (tic < (YEAR_SEC / 2)) {
  1278.         tic = YEAR_SEC / 2;
  1279.         }
  1280.         timelevel[axis] = 6;    /* year */
  1281.     }
  1282.     }
  1283.     return (tic);
  1284. }
  1285. /*}}} */
  1286.  
  1287.  
  1288. void do_plot(plots, pcount)
  1289. struct curve_points *plots;
  1290. int pcount;            /* count of plots in linked list */
  1291. {
  1292.  
  1293. /* BODGES BEFORE I FIX IT UP */
  1294. #define ytic ticstep[y_axis]
  1295. #define xtic ticstep[x_axis]
  1296.  
  1297.     register struct termentry *t = term;
  1298.     register int curve;
  1299.     int axis_zero[AXIS_ARRAY_SIZE];    /* axes in terminal coords for FIRST_X_AXIS, etc */
  1300.     register struct curve_points *this_plot = NULL;
  1301.     register int xl = 0, yl = 0;    /* avoid gcc -Wall warning */
  1302.     register int key_count = 0;
  1303.     /* only a Pyramid would have this many registers! */
  1304.     struct text_label *this_label;
  1305.     struct arrow_def *this_arrow;
  1306.     TBOOLEAN scaling;
  1307.     char ss[MAX_LINE_LEN + 1], *s, *e;
  1308.  
  1309.     /* so that macros for x_min etc pick up correct values
  1310.      * until this is done properly
  1311.      */
  1312.  
  1313.     x_axis = FIRST_X_AXIS;
  1314.     y_axis = FIRST_Y_AXIS;
  1315.  
  1316. /*      Apply the desired viewport offsets. */
  1317.     if (y_min < y_max) {
  1318.     y_min -= boff;
  1319.     y_max += toff;
  1320.     } else {
  1321.     y_max -= boff;
  1322.     y_min += toff;
  1323.     }
  1324.     if (x_min < x_max) {
  1325.     x_min -= loff;
  1326.     x_max += roff;
  1327.     } else {
  1328.     x_max -= loff;
  1329.     x_min += roff;
  1330.     }
  1331.  
  1332.     /*
  1333.      * In the beginning, this "empty range" test was for exact
  1334.      * equality, eg  y_min == y_max , but that caused an infinite
  1335.      * loop once.  Then the test was changed to check for being
  1336.      * within the 'zero' threshold,  fabs(y_max - y_min) < zero) ,
  1337.      * but that prevented plotting data with ranges below 'zero'.
  1338.      * Now it's an absolute equality test again, since  fixup_range()
  1339.      * should have widened empty ranges before we get here.
  1340.      */
  1341.     if (x_min == x_max)
  1342.     int_error("x_min should not equal x_max!", NO_CARET);
  1343.     if (y_min == y_max)
  1344.     int_error("y_min should not equal y_max!", NO_CARET);
  1345.  
  1346.     term_init();        /* may set xmax/ymax */
  1347.  
  1348.     /* compute boundary for plot (xleft, xright, ytop, ybot)
  1349.      * also calculates tics, since xtics depend on xleft
  1350.      * but xleft depends on ytics. Boundary calculations
  1351.      * depend on term->v_char etc, so terminal must be
  1352.      * initialised.
  1353.      */
  1354.  
  1355.     scaling = (*t->scale) (xsize, ysize);
  1356.  
  1357.     boundary(scaling, plots, pcount);
  1358.  
  1359.     screen_ok = FALSE;
  1360.  
  1361.     term_start_plot();
  1362.  
  1363. /* DRAW TICS AND GRID */
  1364.     term_apply_lp_properties(&border_lp);    /* border linetype */
  1365.     largest_polar_circle = 0;
  1366.  
  1367.     /* select first mapping */
  1368.     x_axis = FIRST_X_AXIS;
  1369.     y_axis = FIRST_Y_AXIS;
  1370.  
  1371.     /* label first y axis tics */
  1372.     if (ytics) {
  1373.     int axis = map_x(ZERO);
  1374.     /* set the globals ytick2d_callback() needs */
  1375.  
  1376.     if (rotate_ytics && (*t->text_angle) (1)) {
  1377.         tic_hjust = CENTRE;
  1378.         tic_vjust = JUST_BOT;
  1379.         rotate_tics = 1;    /* HBB 980629 */
  1380.         ytic_x += t->v_char / 2;
  1381.     } else {
  1382.         tic_hjust = RIGHT;
  1383.         tic_vjust = JUST_CENTRE;
  1384.         rotate_tics = 0;    /* HBB 980629 */
  1385.     }
  1386.  
  1387.     if (ytics & TICS_MIRROR)
  1388.         tic_mirror = xright;
  1389.     else
  1390.         tic_mirror = -1;    /* no thank you */
  1391.  
  1392.     if ((ytics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
  1393.         tic_start = axis;
  1394.         tic_direction = -1;
  1395.         if (ytics & TICS_MIRROR)
  1396.         tic_mirror = tic_start;
  1397.         /* put text at boundary if axis is close to boundary */
  1398.         tic_text = (((tic_start - xleft) > (3 * t->h_char)) ? tic_start : xleft) - t->h_char;
  1399.     } else {
  1400.         tic_start = xleft;
  1401.         tic_direction = tic_in ? 1 : -1;
  1402.         tic_text = ytic_x;
  1403.     }
  1404.     /* go for it */
  1405.     gen_tics(FIRST_Y_AXIS, &yticdef,
  1406.          work_grid.l_type & (GRID_Y | GRID_MY),
  1407.          mytics, mytfreq, ytick2d_callback);
  1408.     (*t->text_angle) (0);    /* reset rotation angle */
  1409.  
  1410.     }
  1411.     /* label first x axis tics */
  1412.     if (xtics) {
  1413.     int axis = map_y(ZERO);
  1414.     /* set the globals xtick2d_callback() needs */
  1415.  
  1416.     if (rotate_xtics && (*t->text_angle) (1)) {
  1417.         tic_hjust = RIGHT;
  1418.         tic_vjust = JUST_CENTRE;
  1419.         rotate_tics = 1;    /* HBB 980629 */
  1420.     } else {
  1421.         tic_hjust = CENTRE;
  1422.         tic_vjust = JUST_TOP;
  1423.         rotate_tics = 0;    /* HBB 980629 */
  1424.     }
  1425.  
  1426.     if (xtics & TICS_MIRROR)
  1427.         tic_mirror = ytop;
  1428.     else
  1429.         tic_mirror = -1;    /* no thank you */
  1430.     if ((xtics & TICS_ON_AXIS) && !log_array[FIRST_Y_AXIS] && inrange(axis, ybot, ytop)) {
  1431.         tic_start = axis;
  1432.         tic_direction = -1;
  1433.         if (xtics & TICS_MIRROR)
  1434.         tic_mirror = tic_start;
  1435.         /* put text at boundary if axis is close to boundary */
  1436.         if (tic_start - ybot > 2 * t->v_char)
  1437.         tic_text = tic_start - ticscale * t->v_tic - t->v_char;
  1438.         else
  1439.         tic_text = ybot - t->v_char;
  1440.     } else {
  1441.         tic_start = ybot;
  1442.         tic_direction = tic_in ? 1 : -1;
  1443.         tic_text = xtic_y;
  1444.     }
  1445.     /* go for it */
  1446.     gen_tics(FIRST_X_AXIS, &xticdef,
  1447.          work_grid.l_type & (GRID_X | GRID_MX),
  1448.          mxtics, mxtfreq, xtick2d_callback);
  1449.     (*t->text_angle) (0);    /* reset rotation angle */
  1450.     }
  1451.     /* select second mapping */
  1452.     x_axis = SECOND_X_AXIS;
  1453.     y_axis = SECOND_Y_AXIS;
  1454.  
  1455.     /* label second y axis tics */
  1456.     if (y2tics) {
  1457.     /* set the globalss ytick2d_callback() needs */
  1458.     int axis = map_x(ZERO);
  1459.  
  1460.     if (rotate_y2tics && (*t->text_angle) (1)) {
  1461.         tic_hjust = CENTRE;
  1462.         tic_vjust = JUST_TOP;
  1463.         rotate_tics = 1;    /* HBB 980629 */
  1464.     } else {
  1465.         tic_hjust = LEFT;
  1466.         tic_vjust = JUST_CENTRE;
  1467.         rotate_tics = 0;    /* HBB 980629 */
  1468.     }
  1469.  
  1470.     if (y2tics & TICS_MIRROR)
  1471.         tic_mirror = xleft;
  1472.     else
  1473.         tic_mirror = -1;    /* no thank you */
  1474.     if ((y2tics & TICS_ON_AXIS) && !log_array[FIRST_X_AXIS] && inrange(axis, xleft, xright)) {
  1475.         tic_start = axis;
  1476.         tic_direction = 1;
  1477.         if (y2tics & TICS_MIRROR)
  1478.         tic_mirror = tic_start;
  1479.         /* put text at boundary if axis is close to boundary */
  1480.         tic_text = (((xright - tic_start) > (3 * t->h_char)) ? tic_start : xright) + t->h_char;
  1481.     } else {
  1482.         tic_start = xright;
  1483.         tic_direction = tic_in ? -1 : 1;
  1484.         tic_text = y2tic_x;
  1485.     }
  1486.     /* go for it */
  1487.     gen_tics(SECOND_Y_AXIS, &y2ticdef,
  1488.          work_grid.l_type & (GRID_Y2 | GRID_MY2),
  1489.          my2tics, my2tfreq, ytick2d_callback);
  1490.     (*t->text_angle) (0);    /* reset rotation angle */
  1491.     }
  1492.     /* label second x axis tics */
  1493.     if (x2tics) {
  1494.     int axis = map_y(ZERO);
  1495.     /* set the globals xtick2d_callback() needs */
  1496.  
  1497.     if (rotate_x2tics && (*t->text_angle) (1)) {
  1498.         tic_hjust = LEFT;
  1499.         tic_vjust = JUST_CENTRE;
  1500.         rotate_tics = 1;    /* HBB 980629 */
  1501.     } else {
  1502.         tic_hjust = CENTRE;
  1503.         tic_vjust = JUST_BOT;
  1504.         rotate_tics = 0;    /* HBB 980629 */
  1505.     }
  1506.  
  1507.     if (x2tics & TICS_MIRROR)
  1508.         tic_mirror = ybot;
  1509.     else
  1510.         tic_mirror = -1;    /* no thank you */
  1511.     if ((x2tics & TICS_ON_AXIS) && !log_array[SECOND_Y_AXIS] && inrange(axis, ybot, ytop)) {
  1512.         tic_start = axis;
  1513.         tic_direction = 1;
  1514.         if (x2tics & TICS_MIRROR)
  1515.         tic_mirror = tic_start;
  1516.         /* put text at boundary if axis is close to boundary */
  1517.         tic_text = (((ytop - tic_start) > (2 * t->v_char)) ? tic_start : ytop) + t->v_char;
  1518.     } else {
  1519.         tic_start = ytop;
  1520.         tic_direction = tic_in ? -1 : 1;
  1521.         tic_text = x2tic_y;
  1522.     }
  1523.     /* go for it */
  1524.     gen_tics(SECOND_X_AXIS, &x2ticdef,
  1525.          work_grid.l_type & (GRID_X2 | GRID_MX2),
  1526.          mx2tics, mx2tfreq, xtick2d_callback);
  1527.     (*t->text_angle) (0);    /* reset rotation angle */
  1528.     }
  1529.     /* select first mapping */
  1530.     x_axis = FIRST_X_AXIS;
  1531.     y_axis = FIRST_Y_AXIS;
  1532.  
  1533. /* RADIAL LINES FOR POLAR GRID */
  1534.  
  1535.     /* note that draw_clip_line takes unsigneds, but (fortunately)
  1536.      * clip_line takes signeds
  1537.      */
  1538.     if (polar_grid_angle) {
  1539.     double theta = 0;
  1540.     int ox = map_x(0);
  1541.     int oy = map_y(0);
  1542.     term_apply_lp_properties(&grid_lp);
  1543.     for (theta = 0; theta < 6.29; theta += polar_grid_angle) {
  1544.         /* copy ox in case it gets moved (but it shouldn't) */
  1545.         int oox = ox;
  1546.         int ooy = oy;
  1547.         int x = map_x(largest_polar_circle * cos(theta));
  1548.         int y = map_y(largest_polar_circle * sin(theta));
  1549.         if (clip_line(&oox, &ooy, &x, &y)) {
  1550.         (*t->move) ((unsigned int) oox, (unsigned int) ooy);
  1551.         (*t->vector) ((unsigned int) x, (unsigned int) y);
  1552.         }
  1553.     }
  1554.     draw_clip_line(ox, oy,
  1555.                map_x(largest_polar_circle * cos(theta)),
  1556.                map_y(largest_polar_circle * sin(theta)));
  1557.     }
  1558. /* DRAW AXES */
  1559.  
  1560.     /* after grid so that axes linetypes are on top */
  1561.  
  1562.     x_axis = FIRST_X_AXIS;
  1563.     y_axis = FIRST_Y_AXIS;    /* chose scaling */
  1564.     axis_zero[FIRST_X_AXIS] = map_y(0.0);
  1565.     axis_zero[FIRST_Y_AXIS] = map_x(0.0);
  1566.  
  1567.     if (axis_zero[FIRST_X_AXIS] < ybot || is_log_y)
  1568.     axis_zero[FIRST_X_AXIS] = ybot;        /* save for impulse plotting */
  1569.     else if (axis_zero[FIRST_X_AXIS] >= ytop)
  1570.     axis_zero[FIRST_X_AXIS] = ytop;
  1571.     else if (xzeroaxis.l_type > -3) {
  1572.     term_apply_lp_properties(&xzeroaxis);
  1573.     (*t->move) (xleft, axis_zero[FIRST_X_AXIS]);
  1574.     (*t->vector) (xright, axis_zero[FIRST_X_AXIS]);
  1575.     }
  1576.     if ((yzeroaxis.l_type > -3) && !is_log_x
  1577.                 && axis_zero[FIRST_Y_AXIS] >= xleft
  1578.                 && axis_zero[FIRST_Y_AXIS] < xright) {
  1579.     term_apply_lp_properties(&yzeroaxis);
  1580.     (*t->move) (axis_zero[FIRST_Y_AXIS], ybot);
  1581.     (*t->vector) (axis_zero[FIRST_Y_AXIS], ytop);
  1582.     }
  1583.     x_axis = SECOND_X_AXIS;
  1584.     y_axis = SECOND_Y_AXIS;    /* chose scaling */
  1585.     axis_zero[SECOND_X_AXIS] = map_y(0.0);
  1586.     axis_zero[SECOND_Y_AXIS] = map_x(0.0);
  1587.  
  1588.     if (axis_zero[SECOND_X_AXIS] < ybot || is_log_y2)
  1589.     axis_zero[SECOND_X_AXIS] = ybot;    /* save for impulse plotting */
  1590.     else if (axis_zero[SECOND_X_AXIS] >= ytop)
  1591.     axis_zero[SECOND_X_AXIS] = ytop;
  1592.     else if (x2zeroaxis.l_type > -3) {
  1593.     term_apply_lp_properties(&x2zeroaxis);
  1594.     (*t->move) (xleft, axis_zero[SECOND_X_AXIS]);
  1595.     (*t->vector) (xright, axis_zero[SECOND_X_AXIS]);
  1596.     }
  1597.     if ((y2zeroaxis.l_type > -3) && !is_log_x2 && axis_zero[SECOND_Y_AXIS] >= xleft &&
  1598.     axis_zero[SECOND_Y_AXIS] < xright) {
  1599.     term_apply_lp_properties(&y2zeroaxis);
  1600.     (*t->move) (axis_zero[SECOND_Y_AXIS], ybot);
  1601.     (*t->vector) (axis_zero[SECOND_Y_AXIS], ytop);
  1602.     }
  1603.     /* DRAW PLOT BORDER */
  1604.     if (draw_border) {
  1605.     /* HBB 980609: just in case: move over to border linestyle only
  1606.      * if border is to be drawn */
  1607.     term_apply_lp_properties(&border_lp);    /* border linetype */
  1608.     (*t->move) (xleft, ybot);
  1609.     if (border_south) {
  1610.         (*t->vector) (xright, ybot);
  1611.     } else {
  1612.         (*t->move) (xright, ybot);
  1613.     }
  1614.     if (border_east) {
  1615.         (*t->vector) (xright, ytop);
  1616.     } else {
  1617.         (*t->move) (xright, ytop);
  1618.     }
  1619.     if (border_north) {
  1620.         (*t->vector) (xleft, ytop);
  1621.     } else {
  1622.         (*t->move) (xleft, ytop);
  1623.     }
  1624.     if (border_west) {
  1625.         (*t->vector) (xleft, ybot);
  1626.     } else {
  1627.         (*t->move) (xleft, ybot);
  1628.     }
  1629.     }
  1630. /* YLABEL */
  1631.     if (*ylabel.text) {
  1632.     strcpy(ss, ylabel.text);
  1633.     /* we worked out x-posn in boundary() */
  1634.     if ((*t->text_angle) (1)) {
  1635.         unsigned int x = ylabel_x + (t->v_char / 2);
  1636.         unsigned int y = (ytop + ybot) / 2 + ylabel.yoffset * (t->h_char);
  1637.         write_multiline(x, y, ss, CENTRE, JUST_TOP, 1, ylabel.font);
  1638.         (*t->text_angle) (0);
  1639.     } else {
  1640.         /* really bottom just, but we know number of lines 
  1641.            so we need to adjust x-posn by one line */
  1642.         unsigned int x = ylabel_x;
  1643.         unsigned int y = ylabel_y;
  1644.         write_multiline(x, y, ss, LEFT, JUST_TOP, 0, ylabel.font);
  1645.     }
  1646.     }
  1647. /* Y2LABEL */
  1648.     if (*y2label.text) {
  1649.     strcpy(ss, y2label.text);
  1650.     /* we worked out coordinates in boundary() */
  1651.     if ((*t->text_angle) (1)) {
  1652.         unsigned int x = y2label_x + (t->v_char / 2) - 1;
  1653.         unsigned int y = (ytop + ybot) / 2 + y2label.yoffset * (t->h_char);
  1654.         write_multiline(x, y, ss, CENTRE, JUST_TOP, 1, y2label.font);
  1655.         (*t->text_angle) (0);
  1656.     } else {
  1657.         /* really bottom just, but we know number of lines */
  1658.         unsigned int x = y2label_x;
  1659.         unsigned int y = y2label_y;
  1660.         write_multiline(x, y, ss, RIGHT, JUST_TOP, 0, y2label.font);
  1661.     }
  1662.     }
  1663. /* XLABEL */
  1664.     if (*xlabel.text) {
  1665.     unsigned int x = (xright + xleft) / 2 + xlabel.xoffset * (t->h_char);
  1666.     unsigned int y = xlabel_y - t->v_char / 2;    /* HBB */
  1667.     strcpy(ss, xlabel.text);
  1668.     write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, xlabel.font);
  1669.     }
  1670. /* PLACE TITLE */
  1671.     if (*title.text) {
  1672.     /* we worked out y-coordinate in boundary() */
  1673.     unsigned int x = (xleft + xright) / 2 + title.xoffset * t->h_char;
  1674.     unsigned int y = title_y - t->v_char / 2;
  1675.     strcpy(ss, title.text);
  1676.     write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, title.font);
  1677.     }
  1678. /* X2LABEL */
  1679.     if (*x2label.text) {
  1680.     /* we worked out y-coordinate in boundary() */
  1681.     unsigned int x = (xright + xleft) / 2 + x2label.xoffset * (t->h_char);
  1682.     unsigned int y = x2label_y - t->v_char / 2 - 1;
  1683.     strcpy(ss, x2label.text);
  1684.     write_multiline(x, y, ss, CENTRE, JUST_TOP, 0, x2label.font);
  1685.     }
  1686. /* PLACE TIMEDATE */
  1687.     if (*timelabel.text) {
  1688.     /* we worked out coordinates in boundary() */
  1689.     char str[MAX_LINE_LEN + 1];
  1690.     time_t now;
  1691.     unsigned int x = time_x;
  1692.     unsigned int y = time_y;
  1693.     time(&now);
  1694.     strftime(str, MAX_LINE_LEN, timelabel.text, localtime(&now));
  1695.  
  1696.     if (timelabel_rotate && (*t->text_angle) (1)) {
  1697.         x += t->v_char / 2;    /* HBB */
  1698.         if (timelabel_bottom)
  1699.         write_multiline(x, y, str, LEFT, JUST_TOP, 1, timelabel.font);
  1700.         else
  1701.         write_multiline(x, y, str, RIGHT, JUST_TOP, 1, timelabel.font);
  1702.         (*t->text_angle) (0);
  1703.     } else {
  1704.         y -= t->v_char / 2;    /* HBB */
  1705.         if (timelabel_bottom)
  1706.         write_multiline(x, y, str, LEFT, JUST_BOT, 0, timelabel.font);
  1707.         else
  1708.         write_multiline(x, y, str, LEFT, JUST_TOP, 0, timelabel.font);
  1709.     }
  1710.     }
  1711. /* PLACE LABELS */
  1712.     for (this_label = first_label; this_label != NULL;
  1713.      this_label = this_label->next) {
  1714.     unsigned int x, y;
  1715.     map_position(&this_label->place, &x, &y, "label");
  1716.     strcpy(ss, this_label->text);
  1717.     if (this_label->rotate && (*t->text_angle) (1)) {
  1718.         write_multiline(x, y, ss, this_label->pos, JUST_TOP, 1, this_label->font);
  1719.         (*t->text_angle) (0);
  1720.     } else {
  1721.         write_multiline(x, y, ss, this_label->pos, JUST_TOP, 0, this_label->font);
  1722.     }
  1723.     }
  1724.  
  1725. /* PLACE ARROWS */
  1726.     for (this_arrow = first_arrow; this_arrow != NULL;
  1727.      this_arrow = this_arrow->next) {
  1728.     unsigned int sx, sy, ex, ey;
  1729.     map_position(&this_arrow->start, &sx, &sy, "arrow");
  1730.     map_position(&this_arrow->end, &ex, &ey, "arrow");
  1731.  
  1732.     term_apply_lp_properties(&(this_arrow->lp_properties));
  1733.     (*t->arrow) (sx, sy, ex, ey, this_arrow->head);
  1734.     }
  1735.  
  1736. /* WORK OUT KEY SETTINGS AND DO KEY TITLE / BOX */
  1737.  
  1738.  
  1739.     if (lkey) {            /* may have been cancelled if something went wrong */
  1740.     /* just use key_xl etc worked out in boundary() */
  1741.     xl = key_xl + key_size_left;
  1742.     yl = key_yt;
  1743.  
  1744.     if (*key_title) {
  1745.         sprintf(ss, "%s\n", key_title);
  1746.         s = ss;
  1747.         yl -= t->v_char / 2;
  1748.         while ((e = (char *) strchr(s, '\n')) != NULL) {
  1749.         *e = '\0';
  1750.         if (key_just == JLEFT) {
  1751.             (*t->justify_text) (LEFT);
  1752.             (*t->put_text) (xl + key_text_left, yl, s);
  1753.         } else {
  1754.             if ((*t->justify_text) (RIGHT)) {
  1755.             (*t->put_text) (xl + key_text_right, yl, s);
  1756.             } else {
  1757.             int x = xl + key_text_right - (t->h_char) * strlen(s);
  1758.             if (key_hpos == TOUT || inrange(x, xleft, xright))
  1759.                 (*t->put_text) (x, yl, s);
  1760.             }
  1761.         }
  1762.         s = ++e;
  1763.         yl -= t->v_char;
  1764.         }
  1765.         yl += t->v_char / 2;
  1766.     }
  1767.     yl_ref = yl -= key_entry_height / 2;    /* centralise the keys */
  1768.     key_count = 0;
  1769.  
  1770.     if (key_box.l_type > -3) {
  1771.         term_apply_lp_properties(&key_box);
  1772.         (*t->move) (key_xl, key_yb);
  1773.         (*t->vector) (key_xl, key_yt);
  1774.         (*t->vector) (key_xr, key_yt);
  1775.         (*t->vector) (key_xr, key_yb);
  1776.         (*t->vector) (key_xl, key_yb);
  1777.         /* draw a horizontal line between key title
  1778.    and first entry                          *//* JFi */
  1779.         (*t->move) (key_xl, key_yt - (ktitl_lines) * t->v_char);    /* JFi */
  1780.         (*t->vector) (key_xr, key_yt - (ktitl_lines) * t->v_char);    /* JFi */
  1781.     }
  1782.     }                /* lkey */
  1783.     /* DRAW CURVES */
  1784.     this_plot = plots;
  1785.     for (curve = 0; curve < pcount; this_plot = this_plot->next_cp, curve++) {
  1786.     int localkey = lkey;    /* a local copy */
  1787.  
  1788.     /* set scaling for this plot's axes */
  1789.     x_axis = this_plot->x_axis;
  1790.     y_axis = this_plot->y_axis;
  1791.  
  1792.     term_apply_lp_properties(&(this_plot->lp_properties));
  1793.  
  1794.     if (this_plot->title && !*this_plot->title) {
  1795.         localkey = 0;
  1796.     } else {
  1797.         if (localkey != 0 && this_plot->title) {
  1798.         key_count++;
  1799.         if (key_just == JLEFT) {
  1800.             (*t->justify_text) (LEFT);
  1801.             (*t->put_text) (xl + key_text_left,
  1802.                     yl, this_plot->title);
  1803.         } else {
  1804.             if ((*t->justify_text) (RIGHT)) {
  1805.             (*t->put_text) (xl + key_text_right,
  1806.                     yl, this_plot->title);
  1807.             } else {
  1808.             int x = xl + key_text_right - (t->h_char) * strlen(this_plot->title);
  1809.             if (key_hpos == TOUT ||
  1810.                 i_inrange(x, xleft, xright))
  1811.                 (*t->put_text) (x, yl, this_plot->title);
  1812.             }
  1813.         }
  1814.  
  1815.         /* draw sample depending on bits set in plot_style */
  1816.         if ((this_plot->plot_style & 1) ||
  1817.             ((this_plot->plot_style & 4) && this_plot->plot_type == DATA)) {    /* errors for data plots only */
  1818.             (*t->move) (xl + key_sample_left, yl);
  1819.             (*t->vector) (xl + key_sample_right, yl);
  1820.         }
  1821.         /* oops - doing the point sample now breaks postscript
  1822.          * terminal for example, which changes current line style
  1823.          * when drawing a point, but does not restore it.
  1824.          * We simply draw the point sample after plotting
  1825.          */
  1826.  
  1827.         if (this_plot->plot_type == DATA &&
  1828.             (this_plot->plot_style & 4) &&
  1829.             bar_size > 0.0) {
  1830.             (*t->move) (xl + key_sample_left, yl + ERRORBARTIC);
  1831.             (*t->vector) (xl + key_sample_left, yl - ERRORBARTIC);
  1832.             (*t->move) (xl + key_sample_right, yl + ERRORBARTIC);
  1833.             (*t->vector) (xl + key_sample_right, yl - ERRORBARTIC);
  1834.         }
  1835.         }
  1836.     }
  1837.  
  1838.     /* and now the curves, plus any special key requirements */
  1839.     /* be sure to draw all lines before drawing any points */
  1840.  
  1841.     switch (this_plot->plot_style) {
  1842.         /*{{{  IMPULSE */
  1843.     case IMPULSES:
  1844.         plot_impulses(this_plot, axis_zero[y_axis], axis_zero[x_axis]);
  1845.         break;
  1846.         /*}}} */
  1847.         /*{{{  LINES */
  1848.     case LINES:
  1849.         plot_lines(this_plot);
  1850.         break;
  1851.         /*}}} */
  1852.         /*{{{  STEPS */
  1853.     case STEPS:
  1854.         plot_steps(this_plot);
  1855.         break;
  1856.         /*}}} */
  1857.         /*{{{  FSTEPS */
  1858.     case FSTEPS:
  1859.         plot_fsteps(this_plot);
  1860.         break;
  1861.         /*}}} */
  1862.         /*{{{  HISTEPS */
  1863.     case HISTEPS:
  1864.         plot_histeps(this_plot);
  1865.         break;
  1866.         /*}}} */
  1867.         /*{{{  POINTSTYLE */
  1868.     case POINTSTYLE:
  1869.         plot_points(this_plot);
  1870.         break;
  1871.         /*}}} */
  1872.         /*{{{  LINESPOINTS */
  1873.     case LINESPOINTS:
  1874.         plot_lines(this_plot);
  1875.         plot_points(this_plot);
  1876.         break;
  1877.         /*}}} */
  1878.         /*{{{  DOTS */
  1879.     case DOTS:
  1880.         if (localkey != 0 && this_plot->title) {
  1881.         (*t->point) (xl + key_point_offset, yl, -1);
  1882.         }
  1883.         plot_dots(this_plot);
  1884.         break;
  1885.         /*}}} */
  1886.         /*{{{  YERRORBARS */
  1887.     case YERRORBARS:{
  1888.         plot_bars(this_plot);
  1889.         plot_points(this_plot);
  1890.         break;
  1891.         }
  1892.         /*}}} */
  1893.         /*{{{  XERRORBARS */
  1894.     case XERRORBARS:{
  1895.         plot_bars(this_plot);
  1896.         plot_points(this_plot);
  1897.         }
  1898.         /*}}} */
  1899.         /*{{{  XYERRORBARS */
  1900.     case XYERRORBARS:
  1901.         plot_bars(this_plot);
  1902.         plot_points(this_plot);
  1903.         break;
  1904.  
  1905.         /*}}} */
  1906.         /*{{{  BOXXYERROR */
  1907.     case BOXXYERROR:
  1908.         plot_boxes(this_plot, axis_zero[x_axis]);
  1909.         break;
  1910.         /*}}} */
  1911.         /*{{{  BOXERROR (falls through to) */
  1912.     case BOXERROR:
  1913.         plot_bars(this_plot);
  1914.         /* no break */
  1915.  
  1916.         /*}}} */
  1917.         /*{{{  BOXES */
  1918.     case BOXES:
  1919.         plot_boxes(this_plot, axis_zero[x_axis]);
  1920.         break;
  1921.         /*}}} */
  1922.         /*{{{  VECTOR */
  1923.     case VECTOR:
  1924.         plot_vectors(this_plot);
  1925.         break;
  1926.  
  1927.         /*}}} */
  1928.         /*{{{  FINANCEBARS */
  1929.     case FINANCEBARS:
  1930.         plot_f_bars(this_plot);
  1931.         break;
  1932.         /*}}} */
  1933.         /*{{{  CANDLESTICKS */
  1934.     case CANDLESTICKS:
  1935.         plot_c_bars(this_plot);
  1936.         break;
  1937.         /*}}} */
  1938.     }
  1939.  
  1940.  
  1941.     if (localkey && this_plot->title) {
  1942.         /* we deferred point sample until now */
  1943.         if (this_plot->plot_style & 2)
  1944.         (*t->point) (xl + key_point_offset, yl,
  1945.                  this_plot->lp_properties.p_type);
  1946.  
  1947.         if (key_count >= key_rows) {
  1948.         yl = yl_ref;
  1949.         xl += key_col_wth;
  1950.         key_count = 0;
  1951.         } else
  1952.         yl = yl - key_entry_height;
  1953.     }
  1954.     }
  1955.  
  1956.     term_end_plot();
  1957. }
  1958.  
  1959.  
  1960. /* BODGES */
  1961. #undef ytic
  1962. #undef xtic
  1963.  
  1964. /* plot_impulses:
  1965.  * Plot the curves in IMPULSES style
  1966.  */
  1967.  
  1968. static void plot_impulses(plot, yaxis_x, xaxis_y)
  1969. struct curve_points *plot;
  1970. int yaxis_x, xaxis_y;
  1971. {
  1972.     int i;
  1973.     int x, y;
  1974.     struct termentry *t = term;
  1975.  
  1976.     for (i = 0; i < plot->p_count; i++) {
  1977.     switch (plot->points[i].type) {
  1978.     case INRANGE:{
  1979.         x = map_x(plot->points[i].x);
  1980.         y = map_y(plot->points[i].y);
  1981.         break;
  1982.         }
  1983.     case OUTRANGE:{
  1984.         if (!inrange(plot->points[i].x, x_min, x_max))
  1985.             continue;
  1986.         x = map_x(plot->points[i].x);
  1987.         if ((y_min < y_max
  1988.              && plot->points[i].y < y_min)
  1989.             || (y_max < y_min
  1990.             && plot->points[i].y > y_min))
  1991.             y = map_y(y_min);
  1992.         else
  1993.             y = map_y(y_max);
  1994.  
  1995.         break;
  1996.         }
  1997.     default:        /* just a safety */
  1998.     case UNDEFINED:{
  1999.         continue;
  2000.         }
  2001.     }
  2002.  
  2003.     if (polar)
  2004.         (*t->move) (yaxis_x, xaxis_y);
  2005.     else
  2006.         (*t->move) (x, xaxis_y);
  2007.     (*t->vector) (x, y);
  2008.     }
  2009.  
  2010. }
  2011.  
  2012. /* plot_lines:
  2013.  * Plot the curves in LINES style
  2014.  */
  2015. static void plot_lines(plot)
  2016. struct curve_points *plot;
  2017. {
  2018.     int i;            /* point index */
  2019.     int x, y;            /* point in terminal coordinates */
  2020.     struct termentry *t = term;
  2021.     enum coord_type prev = UNDEFINED;    /* type of previous point */
  2022.     double ex, ey;        /* an edge point */
  2023.     double lx[2], ly[2];    /* two edge points */
  2024.  
  2025.     for (i = 0; i < plot->p_count; i++) {
  2026.     switch (plot->points[i].type) {
  2027.     case INRANGE:{
  2028.         x = map_x(plot->points[i].x);
  2029.         y = map_y(plot->points[i].y);
  2030.  
  2031.         if (prev == INRANGE) {
  2032.             (*t->vector) (x, y);
  2033.         } else if (prev == OUTRANGE) {
  2034.             /* from outrange to inrange */
  2035.             if (!clip_lines1) {
  2036.             (*t->move) (x, y);
  2037.             } else {
  2038.             edge_intersect(plot->points, i, &ex, &ey);
  2039.             (*t->move) (map_x(ex), map_y(ey));
  2040.             (*t->vector) (x, y);
  2041.             }
  2042.         } else {    /* prev == UNDEFINED */
  2043.             (*t->move) (x, y);
  2044.             (*t->vector) (x, y);
  2045.         }
  2046.  
  2047.         break;
  2048.         }
  2049.     case OUTRANGE:{
  2050.         if (prev == INRANGE) {
  2051.             /* from inrange to outrange */
  2052.             if (clip_lines1) {
  2053.             edge_intersect(plot->points, i, &ex, &ey);
  2054.             (*t->vector) (map_x(ex), map_y(ey));
  2055.             }
  2056.         } else if (prev == OUTRANGE) {
  2057.             /* from outrange to outrange */
  2058.             if (clip_lines2) {
  2059.             if (two_edge_intersect(plot->points, i, lx, ly)) {
  2060.                 (*t->move) (map_x(lx[0]), map_y(ly[0]));
  2061.                 (*t->vector) (map_x(lx[1]), map_y(ly[1]));
  2062.             }
  2063.             }
  2064.         }
  2065.         break;
  2066.         }
  2067.     default:        /* just a safety */
  2068.     case UNDEFINED:{
  2069.         break;
  2070.         }
  2071.     }
  2072.     prev = plot->points[i].type;
  2073.     }
  2074. }
  2075.  
  2076. /* XXX - JG  */
  2077. /* plot_steps:                          
  2078.  * Plot the curves in STEPS style
  2079.  */
  2080. static void plot_steps(plot)
  2081. struct curve_points *plot;
  2082. {
  2083.     int i;            /* point index */
  2084.     int x, y;            /* point in terminal coordinates */
  2085.     struct termentry *t = term;
  2086.     enum coord_type prev = UNDEFINED;    /* type of previous point */
  2087.     double ex, ey;        /* an edge point */
  2088.     double lx[2], ly[2];    /* two edge points */
  2089.     int yprev = 0;        /* previous point coordinates */
  2090.  
  2091.     for (i = 0; i < plot->p_count; i++) {
  2092.     switch (plot->points[i].type) {
  2093.     case INRANGE:{
  2094.         x = map_x(plot->points[i].x);
  2095.         y = map_y(plot->points[i].y);
  2096.  
  2097.         if (prev == INRANGE) {
  2098.             (*t->vector) (x, yprev);
  2099.             (*t->vector) (x, y);
  2100.         } else if (prev == OUTRANGE) {
  2101.             /* from outrange to inrange */
  2102.             if (!clip_lines1) {
  2103.             (*t->move) (x, y);
  2104.             } else {    /* find edge intersection */
  2105.             edge_intersect_steps(plot->points, i, &ex, &ey);
  2106.             (*t->move) (map_x(ex), map_y(ey));
  2107.             (*t->vector) (x, map_y(ey));
  2108.             (*t->vector) (x, y);
  2109.             }
  2110.         } else {    /* prev == UNDEFINED */
  2111.             (*t->move) (x, y);
  2112.             (*t->vector) (x, y);
  2113.         }
  2114.         yprev = y;
  2115.         break;
  2116.         }
  2117.     case OUTRANGE:{
  2118.         if (prev == INRANGE) {
  2119.             /* from inrange to outrange */
  2120.             if (clip_lines1) {
  2121.             edge_intersect_steps(plot->points, i, &ex, &ey);
  2122.             (*t->vector) (map_x(ex), yprev);
  2123.             (*t->vector) (map_x(ex), map_y(ey));
  2124.             }
  2125.         } else if (prev == OUTRANGE) {
  2126.             /* from outrange to outrange */
  2127.             if (clip_lines2) {
  2128.             if (two_edge_intersect_steps(plot->points, i, lx, ly)) {
  2129.                 (*t->move) (map_x(lx[0]), map_y(ly[0]));
  2130.                 (*t->vector) (map_x(lx[1]), map_y(ly[0]));
  2131.                 (*t->vector) (map_x(lx[1]), map_y(ly[1]));
  2132.             }
  2133.             }
  2134.         }
  2135.         break;
  2136.         }
  2137.     default:        /* just a safety */
  2138.     case UNDEFINED:{
  2139.         break;
  2140.         }
  2141.     }
  2142.     prev = plot->points[i].type;
  2143.     }
  2144. }
  2145. /* XXX - HOE  */
  2146. /* plot_fsteps:                         
  2147.  * Plot the curves in STEPS style by step on forward yvalue
  2148.  */
  2149. static void plot_fsteps(plot)
  2150. struct curve_points *plot;
  2151. {
  2152.     int i;            /* point index */
  2153.     int x, y;            /* point in terminal coordinates */
  2154.     struct termentry *t = term;
  2155.     enum coord_type prev = UNDEFINED;    /* type of previous point */
  2156.     double ex, ey;        /* an edge point */
  2157.     double lx[2], ly[2];    /* two edge points */
  2158.     int xprev = 0;        /* previous point coordinates */
  2159.  
  2160.     for (i = 0; i < plot->p_count; i++) {
  2161.     switch (plot->points[i].type) {
  2162.     case INRANGE:{
  2163.         x = map_x(plot->points[i].x);
  2164.         y = map_y(plot->points[i].y);
  2165.  
  2166.         if (prev == INRANGE) {
  2167.             (*t->vector) (xprev, y);
  2168.             (*t->vector) (x, y);
  2169.         } else if (prev == OUTRANGE) {
  2170.             /* from outrange to inrange */
  2171.             if (!clip_lines1) {
  2172.             (*t->move) (x, y);
  2173.             } else {    /* find edge intersection */
  2174.             edge_intersect_fsteps(plot->points, i, &ex, &ey);
  2175.             (*t->move) (map_x(ex), map_y(ey));
  2176.             (*t->vector) (map_x(ex), y);
  2177.             (*t->vector) (x, y);
  2178.             }
  2179.         } else {    /* prev == UNDEFINED */
  2180.             (*t->move) (x, y);
  2181.             (*t->vector) (x, y);
  2182.         }
  2183.         xprev = x;
  2184.         break;
  2185.         }
  2186.     case OUTRANGE:{
  2187.         if (prev == INRANGE) {
  2188.             /* from inrange to outrange */
  2189.             if (clip_lines1) {
  2190.             edge_intersect_fsteps(plot->points, i, &ex, &ey);
  2191.             (*t->vector) (xprev, map_y(ey));
  2192.             (*t->vector) (map_x(ex), map_y(ey));
  2193.             }
  2194.         } else if (prev == OUTRANGE) {
  2195.             /* from outrange to outrange */
  2196.             if (clip_lines2) {
  2197.             if (two_edge_intersect_fsteps(plot->points, i, lx, ly)) {
  2198.                 (*t->move) (map_x(lx[0]), map_y(ly[0]));
  2199.                 (*t->vector) (map_x(lx[0]), map_y(ly[1]));
  2200.                 (*t->vector) (map_x(lx[1]), map_y(ly[1]));
  2201.             }
  2202.             }
  2203.         }
  2204.         break;
  2205.         }
  2206.     default:        /* just a safety */
  2207.     case UNDEFINED:{
  2208.         break;
  2209.         }
  2210.     }
  2211.     prev = plot->points[i].type;
  2212.     }
  2213. }
  2214.  
  2215. /* CAC  */
  2216. /* plot_histeps:                                
  2217.  * Plot the curves in HISTEPS style
  2218.  */
  2219. static void plot_histeps(plot)
  2220. struct curve_points *plot;
  2221. {
  2222.     int i;            /* point index */
  2223.     int hold, bigi;        /* indices for sorting */
  2224.     int xl, yl;            /* cursor position in terminal coordinates */
  2225.     struct termentry *t = term;
  2226.     double x, y, xn, yn;    /* point position */
  2227.     int *gl, goodcount;        /* array to hold list of valid points */
  2228.  
  2229.     /* preliminary count of points inside array */
  2230.     goodcount = 0;
  2231.     for (i = 0; i < plot->p_count; i++)
  2232.     if (plot->points[i].type == INRANGE ||
  2233.         plot->points[i].type == OUTRANGE)
  2234.         ++goodcount;
  2235.     if (goodcount < 2)
  2236.     return;            /* cannot plot less than 2 points */
  2237.  
  2238.     gl = (int *) gp_alloc(goodcount * sizeof(int), "histeps valid point mapping");
  2239.     if (gl == NULL)
  2240.     return;
  2241.  
  2242. /* fill gl array with indexes of valid (non-undefined) points.  */
  2243.     goodcount = 0;
  2244.     for (i = 0; i < plot->p_count; i++)
  2245.     if (plot->points[i].type == INRANGE ||
  2246.         plot->points[i].type == OUTRANGE) {
  2247.         gl[goodcount] = i;
  2248.         ++goodcount;
  2249.     }
  2250. /* sort the data */
  2251.     for (bigi = i = 1; i < goodcount;) {
  2252.     if (plot->points[gl[i]].x < plot->points[gl[i - 1]].x) {
  2253.         hold = gl[i];
  2254.         gl[i] = gl[i - 1];
  2255.         gl[i - 1] = hold;
  2256.         if (i > 1) {
  2257.         i--;
  2258.         continue;
  2259.         }
  2260.     }
  2261.     i = ++bigi;
  2262.     }
  2263.  
  2264.     x = (3.0 * plot->points[gl[0]].x - plot->points[gl[1]].x) / 2.0;
  2265.     y = 0.0;
  2266.  
  2267.     xl = map_x(x);
  2268.     yl = map_y(y);
  2269.     (*t->move) (xl, yl);
  2270.  
  2271.     for (i = 0; i < goodcount - 1; i++) {    /* loop over all points except last  */
  2272.  
  2273.     yn = plot->points[gl[i]].y;
  2274.     xn = (plot->points[gl[i]].x + plot->points[gl[i + 1]].x) / 2.0;
  2275.     histeps_vertical(&xl, &yl, x, y, yn);
  2276.     histeps_horizontal(&xl, &yl, x, xn, yn);
  2277.  
  2278.     x = xn;
  2279.     y = yn;
  2280.     }
  2281.  
  2282.     yn = plot->points[gl[i]].y;
  2283.     xn = (3.0 * plot->points[gl[i]].x - plot->points[gl[i - 1]].x) / 2.0;
  2284.     histeps_vertical(&xl, &yl, x, y, yn);
  2285.     histeps_horizontal(&xl, &yl, x, xn, yn);
  2286.     histeps_vertical(&xl, &yl, xn, yn, 0.0);
  2287.  
  2288.     free(gl);
  2289. }
  2290. /* CAC 
  2291.  * Draw vertical line for the histeps routine.
  2292.  * Performs clipping.
  2293.  */
  2294. static void histeps_vertical(xl, yl, x, y1, y2)
  2295. int *xl, *yl;            /* keeps track of "cursor" position */
  2296. double x, y1, y2;        /* coordinates of vertical line */
  2297. {
  2298.     struct termentry *t = term;
  2299.     /* global x_min, x_max, y_min, y_max */
  2300.     int xm, y1m, y2m;
  2301.  
  2302.     if ((y1 < y_min && y2 < y_min) ||
  2303.     (y1 > y_max && y2 > y_max) ||
  2304.     x < x_min ||
  2305.     x > x_max)
  2306.     return;
  2307.  
  2308.     if (y1 < y_min)
  2309.     y1 = y_min;
  2310.     if (y1 > y_max)
  2311.     y1 = y_max;
  2312.     if (y2 < y_min)
  2313.     y2 = y_min;
  2314.     if (y2 > y_max)
  2315.     y2 = y_max;
  2316.  
  2317.     xm = map_x(x);
  2318.     y1m = map_y(y1);
  2319.     y2m = map_y(y2);
  2320.  
  2321.     if (y1m != *yl || xm != *xl)
  2322.     (*t->move) (xm, y1m);
  2323.     (*t->vector) (xm, y2m);
  2324.     *xl = xm;
  2325.     *yl = y2m;
  2326.  
  2327.     return;
  2328. }
  2329. /* CAC 
  2330.  * Draw horizontal line for the histeps routine.
  2331.  * Performs clipping.
  2332.  */
  2333. static void histeps_horizontal(xl, yl, x1, x2, y)
  2334. int *xl, *yl;            /* keeps track of "cursor" position */
  2335. double x1, x2, y;        /* coordinates of vertical line */
  2336. {
  2337.     struct termentry *t = term;
  2338.     /* global x_min, x_max, y_min, y_max */
  2339.     int x1m, x2m, ym;
  2340.  
  2341.     if ((x1 < x_min && x2 < x_min) ||
  2342.     (x1 > x_max && x2 > x_max) ||
  2343.     y < y_min ||
  2344.     y > y_max)
  2345.     return;
  2346.  
  2347.     if (x1 < x_min)
  2348.     x1 = x_min;
  2349.     if (x1 > x_max)
  2350.     x1 = x_max;
  2351.     if (x2 < x_min)
  2352.     x2 = x_min;
  2353.     if (x2 > x_max)
  2354.     x2 = x_max;
  2355.  
  2356.     ym = map_y(y);
  2357.     x1m = map_x(x1);
  2358.     x2m = map_x(x2);
  2359.  
  2360.     if (x1m != *xl || ym != *yl)
  2361.     (*t->move) (x1m, ym);
  2362.     (*t->vector) (x2m, ym);
  2363.     *xl = x2m;
  2364.     *yl = ym;
  2365.  
  2366.     return;
  2367. }
  2368.  
  2369.  
  2370. /* plot_bars:
  2371.  * Plot the curves in ERRORBARS style
  2372.  *  we just plot the bars; the points are plotted in plot_points
  2373.  */
  2374. static void plot_bars(plot)
  2375. struct curve_points *plot;
  2376. {
  2377.     int i;            /* point index */
  2378.     struct termentry *t = term;
  2379.     double x, y;        /* position of the bar */
  2380.     double ylow, yhigh;        /* the ends of the bars */
  2381.     double xlow, xhigh;
  2382.     double x1, y1, x2, y2, slope;    /* parameters for polar error bars */
  2383.     unsigned int xM, ylowM, yhighM;    /* the mapped version of above */
  2384.     unsigned int yM, xlowM, xhighM;
  2385.     TBOOLEAN low_inrange, high_inrange;
  2386.     int tic = ERRORBARTIC;
  2387.  
  2388. /* Limitation: no boxes with x errorbars */
  2389.  
  2390.     if ((plot->plot_style == YERRORBARS) || (plot->plot_style == XYERRORBARS) ||
  2391.     (plot->plot_style == BOXERROR)) {
  2392. /* Draw the vertical part of the bar */
  2393.     for (i = 0; i < plot->p_count; i++) {
  2394.         /* undefined points don't count */
  2395.         if (plot->points[i].type == UNDEFINED)
  2396.         continue;
  2397.  
  2398.         /* check to see if in xrange */
  2399.         x = plot->points[i].x;
  2400.         if (!inrange(x, x_min, x_max))
  2401.         continue;
  2402.         xM = map_x(x);
  2403.  
  2404.         /* check to see if in yrange */
  2405.         y = plot->points[i].y;
  2406.         if (!inrange(y, y_min, y_max))
  2407.         continue;
  2408.         yM = map_y(y);
  2409.  
  2410.         /* find low and high points of bar, and check yrange */
  2411.         yhigh = plot->points[i].yhigh;
  2412.         ylow = plot->points[i].ylow;
  2413.  
  2414.         high_inrange = inrange(yhigh, y_min, y_max);
  2415.         low_inrange = inrange(ylow, y_min, y_max);
  2416.  
  2417.         /* compute the plot position of yhigh */
  2418.         if (high_inrange)
  2419.         yhighM = map_y(yhigh);
  2420.         else if (samesign(yhigh - y_max, y_max - y_min))
  2421.         yhighM = map_y(y_max);
  2422.         else
  2423.         yhighM = map_y(y_min);
  2424.  
  2425.         /* compute the plot position of ylow */
  2426.         if (low_inrange)
  2427.         ylowM = map_y(ylow);
  2428.         else if (samesign(ylow - y_max, y_max - y_min))
  2429.         ylowM = map_y(y_max);
  2430.         else
  2431.         ylowM = map_y(y_min);
  2432.  
  2433.         if (!high_inrange && !low_inrange && ylowM == yhighM)
  2434.         /* both out of range on the same side */
  2435.         continue;
  2436.  
  2437.         /* find low and high points of bar, and check xrange */
  2438.         xhigh = plot->points[i].xhigh;
  2439.         xlow = plot->points[i].xlow;
  2440.  
  2441.         high_inrange = inrange(xhigh, x_min, x_max);
  2442.         low_inrange = inrange(xlow, x_min, x_max);
  2443.  
  2444.         /* compute the plot position of xhigh */
  2445.         if (high_inrange)
  2446.         xhighM = map_x(xhigh);
  2447.         else if (samesign(xhigh - x_max, x_max - x_min))
  2448.         xhighM = map_x(x_max);
  2449.         else
  2450.         xhighM = map_x(x_min);
  2451.  
  2452.         /* compute the plot position of xlow */
  2453.         if (low_inrange)
  2454.         xlowM = map_x(xlow);
  2455.         else if (samesign(xlow - x_max, x_max - x_min))
  2456.         xlowM = map_x(x_max);
  2457.         else
  2458.         xlowM = map_x(x_min);
  2459.  
  2460.         if (!high_inrange && !low_inrange && xlowM == xhighM)
  2461.         /* both out of range on the same side */
  2462.         continue;
  2463.  
  2464.         /* by here everything has been mapped */
  2465.         if (!polar) {
  2466.         /* HBB 981130: use Igor's routine *only* for polar errorbars */
  2467.         (*t->move) (xM, ylowM);
  2468.         /* draw the main bar */
  2469.         (*t->vector) (xM, yhighM);
  2470.         if (bar_size > 0.0) {
  2471.             /* draw the bottom tic */
  2472.             (*t->move) ((unsigned int) (xM - bar_size * tic), ylowM);
  2473.             (*t->vector) ((unsigned int) (xM + bar_size * tic), ylowM);
  2474.             /* draw the top tic */
  2475.             (*t->move) ((unsigned int) (xM - bar_size * tic), yhighM);
  2476.             (*t->vector) ((unsigned int) (xM + bar_size * tic), yhighM);
  2477.         }
  2478.         } else {
  2479.         /* HBB 981130: see above */
  2480.         /* The above has been replaced by Igor inorder to get errorbars
  2481.            coming out in polar mode AND to stop the bar from going
  2482.            through the symbol */
  2483.         if ((xhighM - xlowM) * (xhighM - xlowM) + (yhighM - ylowM) * (yhighM - ylowM)
  2484.             > pointsize * tic * pointsize * tic * 4.5) {
  2485.             /* Only plot the error bar if it is bigger than the
  2486.              * symbol */
  2487.             /* The factor of 4.5 should strictly be 4.0, but it looks
  2488.              * better to drop the error bar if it is only slightly
  2489.              * bigger than the symbol, Igor. */
  2490.             if (xlowM == xhighM) {
  2491.             (*t->move) (xM, ylowM);
  2492.             /* draw the main bar to the symbol end */
  2493.             (*t->vector) (xM, (unsigned int) (yM - pointsize * tic));
  2494.             (*t->move) (xM, (unsigned int) (yM + pointsize * tic));
  2495.             /* draw the other part of the main bar */
  2496.             (*t->vector) (xM, yhighM);
  2497.             } else {
  2498.             (*t->move) (xlowM, ylowM);
  2499.             /* draw the main bar in polar mode. Note that here
  2500.              * the bar is drawn through the symbol. I tried to
  2501.              * fix this, but got into trouble with the two bars
  2502.              * (on either side of symbol) not being perfectly
  2503.              * parallel due to mapping considerations. Igor
  2504.              */
  2505.             (*t->vector) (xhighM, yhighM);
  2506.             }
  2507.             if (bar_size > 0.0) {
  2508.             /* The following attempts to ensure that the tics
  2509.              * are perpendicular to the error bar, Igor. */
  2510.             /*perpendicular to the main bar */
  2511.             slope = (xlowM * 1.0 - xhighM * 1.0) / (yhighM * 1.0 - ylowM * 1.0 + 1e-10);
  2512.             x1 = xlowM + bar_size * tic / sqrt(1.0 + slope * slope);
  2513.             x2 = xlowM - bar_size * tic / sqrt(1.0 + slope * slope);
  2514.             y1 = slope * (x1 - xlowM) + ylowM;
  2515.             y2 = slope * (x2 - xlowM) + ylowM;
  2516.  
  2517.             /* draw the bottom tic */
  2518.             (*t->move) ((unsigned int) x1, (unsigned int) y1);
  2519.             (*t->vector) ((unsigned int) x2, (unsigned int) y2);
  2520.  
  2521.             x1 = xhighM + bar_size * tic / sqrt(1.0 + slope * slope);
  2522.             x2 = xhighM - bar_size * tic / sqrt(1.0 + slope * slope);
  2523.             y1 = slope * (x1 - xhighM) + yhighM;
  2524.             y2 = slope * (x2 - xhighM) + yhighM;
  2525.             /* draw the top tic */
  2526.             (*t->move) ((unsigned int) x1, (unsigned int) y1);
  2527.             (*t->vector) ((unsigned int) x2, (unsigned int) y2);
  2528.             }        /* if error bar is bigger than symbol */
  2529.         }
  2530.         }            /* HBB 981130: see above */
  2531.     }            /* for loop */
  2532.     }                /* if yerrorbars OR xyerrorbars */
  2533.     if ((plot->plot_style == XERRORBARS) || (plot->plot_style == XYERRORBARS)) {
  2534.  
  2535. /* Draw the horizontal part of the bar */
  2536.     for (i = 0; i < plot->p_count; i++) {
  2537.         /* undefined points don't count */
  2538.         if (plot->points[i].type == UNDEFINED)
  2539.         continue;
  2540.  
  2541.         /* check to see if in yrange */
  2542.         y = plot->points[i].y;
  2543.         if (!inrange(y, y_min, y_max))
  2544.         continue;
  2545.         yM = map_y(y);
  2546.  
  2547.         /* find low and high points of bar, and check xrange */
  2548.         xhigh = plot->points[i].xhigh;
  2549.         xlow = plot->points[i].xlow;
  2550.  
  2551.         high_inrange = inrange(xhigh, x_min, x_max);
  2552.         low_inrange = inrange(xlow, x_min, x_max);
  2553.  
  2554.         /* compute the plot position of xhigh */
  2555.         if (high_inrange)
  2556.         xhighM = map_x(xhigh);
  2557.         else if (samesign(xhigh - x_max, x_max - x_min))
  2558.         xhighM = map_x(x_max);
  2559.         else
  2560.         xhighM = map_x(x_min);
  2561.  
  2562.         /* compute the plot position of xlow */
  2563.         if (low_inrange)
  2564.         xlowM = map_x(xlow);
  2565.         else if (samesign(xlow - x_max, x_max - x_min))
  2566.         xlowM = map_x(x_max);
  2567.         else
  2568.         xlowM = map_x(x_min);
  2569.  
  2570.         if (!high_inrange && !low_inrange && xlowM == xhighM)
  2571.         /* both out of range on the same side */
  2572.         continue;
  2573.  
  2574.         /* by here everything has been mapped */
  2575.         (*t->move) (xlowM, yM);
  2576.         (*t->vector) (xhighM, yM);    /* draw the main bar */
  2577.         if (bar_size > 0.0) {
  2578.         (*t->move) (xlowM, (unsigned int) (yM - bar_size * tic));    /* draw the left tic */
  2579.         (*t->vector) (xlowM, (unsigned int) (yM + bar_size * tic));
  2580.         (*t->move) (xhighM, (unsigned int) (yM - bar_size * tic));    /* draw the right tic */
  2581.         (*t->vector) (xhighM, (unsigned int) (yM + bar_size * tic));
  2582.         }
  2583.     }            /* for loop */
  2584.     }                /* if xerrorbars OR xyerrorbars */
  2585. }
  2586.  
  2587. /* plot_boxes:
  2588.  * Plot the curves in BOXES style
  2589.  */
  2590. static void plot_boxes(plot, xaxis_y)
  2591. struct curve_points *plot;
  2592. int xaxis_y;
  2593. {
  2594.     int i;            /* point index */
  2595.     int xl, xr, yt;        /* point in terminal coordinates */
  2596.     double dxl, dxr, dyt;
  2597.     struct termentry *t = term;
  2598.     enum coord_type prev = UNDEFINED;    /* type of previous point */
  2599.     TBOOLEAN boxxy = (plot->plot_style == BOXXYERROR);
  2600.  
  2601.     for (i = 0; i < plot->p_count; i++) {
  2602.  
  2603.     switch (plot->points[i].type) {
  2604.     case OUTRANGE:
  2605.     case INRANGE:{
  2606.         if (plot->points[i].z < 0.0) {
  2607.             /* need to auto-calc width */
  2608.             /* ASSERT(boxwidth <= 0.0); - else graphics.c
  2609.              * provides width */
  2610.  
  2611.             /* calculate width */
  2612.             if (prev != UNDEFINED)
  2613.             dxl = (plot->points[i - 1].x - plot->points[i].x) / 2.0;
  2614.             else
  2615.             dxl = 0.0;
  2616.  
  2617.             if (i < plot->p_count - 1) {
  2618.             if (plot->points[i + 1].type != UNDEFINED)
  2619.                 dxr = (plot->points[i + 1].x - plot->points[i].x) / 2.0;
  2620.             else
  2621.                 dxr = -dxl;
  2622.             } else {
  2623.             dxr = -dxl;
  2624.             }
  2625.  
  2626.             if (prev == UNDEFINED)
  2627.             dxl = -dxr;
  2628.  
  2629.             dxl = plot->points[i].x + dxl;
  2630.             dxr = plot->points[i].x + dxr;
  2631.         } else {    /* z >= 0 */
  2632.             dxr = plot->points[i].xhigh;
  2633.             dxl = plot->points[i].xlow;
  2634.         }
  2635.  
  2636.         if (boxxy) {
  2637.             dyt = plot->points[i].yhigh;
  2638.             xaxis_y = map_y(plot->points[i].ylow);
  2639.         } else {
  2640.             dyt = plot->points[i].y;
  2641.         }
  2642.  
  2643.         /* clip to border */
  2644.         if ((y_min < y_max && dyt < y_min)
  2645.             || (y_max < y_min && dyt > y_min))
  2646.             dyt = y_min;
  2647.         if ((y_min < y_max && dyt > y_max)
  2648.             || (y_max < y_min && dyt < y_max))
  2649.             dyt = y_max;
  2650.         if ((x_min < x_max && dxr < x_min)
  2651.             || (x_max < x_min && dxr > x_min))
  2652.             dxr = x_min;
  2653.         if ((x_min < x_max && dxr > x_max)
  2654.             || (x_max < x_min && dxr < x_max))
  2655.             dxr = x_max;
  2656.         if ((x_min < x_max && dxl < x_min)
  2657.             || (x_max < x_min && dxl > x_min))
  2658.             dxl = x_min;
  2659.         if ((x_min < x_max && dxl > x_max)
  2660.             || (x_max < x_min && dxl < x_max))
  2661.             dxl = x_max;
  2662.  
  2663.         xl = map_x(dxl);
  2664.         xr = map_x(dxr);
  2665.         yt = map_y(dyt);
  2666.  
  2667.         (*t->move) (xl, xaxis_y);
  2668.         (*t->vector) (xl, yt);
  2669.         (*t->vector) (xr, yt);
  2670.         (*t->vector) (xr, xaxis_y);
  2671.         (*t->vector) (xl, xaxis_y);
  2672.         break;
  2673.         }            /* case OUTRANGE, INRANGE */
  2674.  
  2675.     default:        /* just a safety */
  2676.     case UNDEFINED:{
  2677.         break;
  2678.         }
  2679.  
  2680.     }            /* switch point-type */
  2681.  
  2682.     prev = plot->points[i].type;
  2683.  
  2684.     }                /*loop */
  2685. }
  2686.  
  2687.  
  2688.  
  2689. /* plot_points:
  2690.  * Plot the curves in POINTSTYLE style
  2691.  */
  2692. static void plot_points(plot)
  2693. struct curve_points *plot;
  2694. {
  2695.     int i;
  2696.     int x, y;
  2697.     struct termentry *t = term;
  2698.  
  2699.     for (i = 0; i < plot->p_count; i++) {
  2700.     if (plot->points[i].type == INRANGE) {
  2701.         x = map_x(plot->points[i].x);
  2702.         y = map_y(plot->points[i].y);
  2703.         /* do clipping if necessary */
  2704.         if (!clip_points ||
  2705.         (x >= xleft + p_width && y >= ybot + p_height
  2706.          && x <= xright - p_width && y <= ytop - p_height))
  2707.         (*t->point) (x, y, plot->lp_properties.p_type);
  2708.     }
  2709.     }
  2710. }
  2711.  
  2712. /* plot_dots:
  2713.  * Plot the curves in DOTS style
  2714.  */
  2715. static void plot_dots(plot)
  2716. struct curve_points *plot;
  2717. {
  2718.     int i;
  2719.     int x, y;
  2720.     struct termentry *t = term;
  2721.  
  2722.     for (i = 0; i < plot->p_count; i++) {
  2723.     if (plot->points[i].type == INRANGE) {
  2724.         x = map_x(plot->points[i].x);
  2725.         y = map_y(plot->points[i].y);
  2726.         /* point type -1 is a dot */
  2727.         (*t->point) (x, y, -1);
  2728.     }
  2729.     }
  2730. }
  2731.  
  2732. /* plot_vectors:
  2733.  * Plot the curves in VECTORS style
  2734.  */
  2735. static void plot_vectors(plot)
  2736. struct curve_points *plot;
  2737. {
  2738.     int i;
  2739.     int x1, y1, x2, y2;
  2740.     struct termentry *t = term;
  2741.  
  2742.     for (i = 0; i < plot->p_count; i++) {
  2743.     if (plot->points[i].type == INRANGE) {
  2744.         x1 = map_x(plot->points[i].xlow);
  2745.         y1 = map_y(plot->points[i].ylow);
  2746.         x2 = map_x(plot->points[i].xhigh);
  2747.         y2 = map_y(plot->points[i].yhigh);
  2748.         (*t->arrow) (x1, y1, x2, y2, TRUE);
  2749.     }
  2750.     }
  2751. }
  2752.  
  2753.  
  2754. /* plot_f_bars() - finance bars */
  2755. static void plot_f_bars(plot)
  2756. struct curve_points *plot;
  2757. {
  2758.     int i;            /* point index */
  2759.     struct termentry *t = term;
  2760.     double x;            /* position of the bar */
  2761.     double ylow, yhigh, yclose, yopen;    /* the ends of the bars */
  2762.     unsigned int xM, ylowM, yhighM;    /* the mapped version of above */
  2763.     TBOOLEAN low_inrange, high_inrange;
  2764.     int tic = ERRORBARTIC / 2;
  2765.  
  2766.     for (i = 0; i < plot->p_count; i++) {
  2767.     /* undefined points don't count */
  2768.     if (plot->points[i].type == UNDEFINED)
  2769.         continue;
  2770.  
  2771.     /* check to see if in xrange */
  2772.     x = plot->points[i].x;
  2773.     if (!inrange(x, x_min, x_max))
  2774.         continue;
  2775.     xM = map_x(x);
  2776.  
  2777.     /* find low and high points of bar, and check yrange */
  2778.     yhigh = plot->points[i].yhigh;
  2779.     ylow = plot->points[i].ylow;
  2780.     yclose = plot->points[i].z;
  2781.     yopen = plot->points[i].y;
  2782.  
  2783.     high_inrange = inrange(yhigh, y_min, y_max);
  2784.     low_inrange = inrange(ylow, y_min, y_max);
  2785.  
  2786.     /* compute the plot position of yhigh */
  2787.     if (high_inrange)
  2788.         yhighM = map_y(yhigh);
  2789.     else if (samesign(yhigh - y_max, y_max - y_min))
  2790.         yhighM = map_y(y_max);
  2791.     else
  2792.         yhighM = map_y(y_min);
  2793.  
  2794.     /* compute the plot position of ylow */
  2795.     if (low_inrange)
  2796.         ylowM = map_y(ylow);
  2797.     else if (samesign(ylow - y_max, y_max - y_min))
  2798.         ylowM = map_y(y_max);
  2799.     else
  2800.         ylowM = map_y(y_min);
  2801.  
  2802.     if (!high_inrange && !low_inrange && ylowM == yhighM)
  2803.         /* both out of range on the same side */
  2804.         continue;
  2805.  
  2806.     /* by here everything has been mapped */
  2807.     (*t->move) (xM, ylowM);
  2808.     (*t->vector) (xM, yhighM);    /* draw the main bar */
  2809.     /* draw the open tic */
  2810.     (*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
  2811.     (*t->vector) (xM, map_y(yopen));
  2812.     /* draw the close tic */
  2813.     (*t->move) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
  2814.     (*t->vector) (xM, map_y(yclose));
  2815.     }
  2816. }
  2817.  
  2818.  
  2819. /* plot_c_bars:
  2820.  * Plot the curves in CANDLESTICSK style
  2821.  *  we just plot the bars; the points are not plotted 
  2822.  */
  2823. static void plot_c_bars(plot)
  2824. struct curve_points *plot;
  2825. {
  2826.     int i;            /* point index */
  2827.     struct termentry *t = term;
  2828.     double x;            /* position of the bar */
  2829.     double ylow, yhigh, yclose, yopen;    /* the ends of the bars */
  2830.     unsigned int xM, ylowM, yhighM;    /* the mapped version of above */
  2831.     TBOOLEAN low_inrange, high_inrange;
  2832.     int tic = ERRORBARTIC / 2;
  2833.  
  2834.     for (i = 0; i < plot->p_count; i++) {
  2835.     /* undefined points don't count */
  2836.     if (plot->points[i].type == UNDEFINED)
  2837.         continue;
  2838.  
  2839.     /* check to see if in xrange */
  2840.     x = plot->points[i].x;
  2841.     if (!inrange(x, x_min, x_max))
  2842.         continue;
  2843.     xM = map_x(x);
  2844.  
  2845.     /* find low and high points of bar, and check yrange */
  2846.     yhigh = plot->points[i].yhigh;
  2847.     ylow = plot->points[i].ylow;
  2848.     yclose = plot->points[i].z;
  2849.     yopen = plot->points[i].y;
  2850.  
  2851.     high_inrange = inrange(yhigh, y_min, y_max);
  2852.     low_inrange = inrange(ylow, y_min, y_max);
  2853.  
  2854.     /* compute the plot position of yhigh */
  2855.     if (high_inrange)
  2856.         yhighM = map_y(yhigh);
  2857.     else if (samesign(yhigh - y_max, y_max - y_min))
  2858.         yhighM = map_y(y_max);
  2859.     else
  2860.         yhighM = map_y(y_min);
  2861.  
  2862.     /* compute the plot position of ylow */
  2863.     if (low_inrange)
  2864.         ylowM = map_y(ylow);
  2865.     else if (samesign(ylow - y_max, y_max - y_min))
  2866.         ylowM = map_y(y_max);
  2867.     else
  2868.         ylowM = map_y(y_min);
  2869.  
  2870.     if (!high_inrange && !low_inrange && ylowM == yhighM)
  2871.         /* both out of range on the same side */
  2872.         continue;
  2873.  
  2874.     /* by here everything has been mapped */
  2875.     if (yopen <= yclose) {
  2876.         (*t->move) (xM, ylowM);
  2877.         (*t->vector) (xM, map_y(yopen));    /* draw the lower bar */
  2878.         /* draw the open tic */
  2879.         (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
  2880.         /* draw the open tic */
  2881.         (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
  2882.         (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
  2883.         (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
  2884.         /* draw the open tic */
  2885.         (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
  2886.         (*t->move) (xM, map_y(yclose));    /* draw the close tic */
  2887.         (*t->vector) (xM, yhighM);
  2888.     } else {
  2889.         (*t->move) (xM, ylowM);
  2890.         (*t->vector) (xM, yhighM);
  2891.         /* draw the open tic */
  2892.         (*t->move) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
  2893.         /* draw the open tic */
  2894.         (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yopen));
  2895.         (*t->vector) ((unsigned int) (xM + bar_size * tic), map_y(yclose));
  2896.         (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yclose));
  2897.         /* draw the open tic */
  2898.         (*t->vector) ((unsigned int) (xM - bar_size * tic), map_y(yopen));
  2899.         /* draw the close tic */
  2900.         (*t->move) ((unsigned int) (xM - bar_size * tic / 2), map_y(yclose));
  2901.         /* draw the open tic */
  2902.         (*t->vector) ((unsigned int) (xM - bar_size * tic / 2), map_y(yopen));
  2903.         /* draw the close tic */
  2904.         (*t->move) ((unsigned int) (xM + bar_size * tic / 2), map_y(yclose));
  2905.         /* draw the open tic */
  2906.         (*t->vector) ((unsigned int) (xM + bar_size * tic / 2), map_y(yopen));
  2907.     }
  2908.  
  2909.     }
  2910. }
  2911.  
  2912. /* single edge intersection algorithm */
  2913. /* Given two points, one inside and one outside the plot, return
  2914.  * the point where an edge of the plot intersects the line segment defined 
  2915.  * by the two points.
  2916.  */
  2917. static void edge_intersect(points, i, ex, ey)
  2918. struct coordinate GPHUGE *points;    /* the points array */
  2919. int i;                /* line segment from point i-1 to point i */
  2920. double *ex, *ey;        /* the point where it crosses an edge */
  2921. {
  2922.     /* global x_min, x_max, y_min, x_max */
  2923.     double ix = points[i - 1].x;
  2924.     double iy = points[i - 1].y;
  2925.     double ox = points[i].x;
  2926.     double oy = points[i].y;
  2927.     double x, y;        /* possible intersection point */
  2928.  
  2929.     if (points[i].type == INRANGE) {
  2930.     /* swap points around so that ix/ix/iz are INRANGE and
  2931.      * ox/oy/oz are OUTRANGE
  2932.      */
  2933.     x = ix;
  2934.     ix = ox;
  2935.     ox = x;
  2936.     y = iy;
  2937.     iy = oy;
  2938.     oy = y;
  2939.     }
  2940.     /* nasty degenerate cases, effectively drawing to an infinity point (?)
  2941.      * cope with them here, so don't process them as a "real" OUTRANGE point 
  2942.      *
  2943.      * If more than one coord is -VERYLARGE, then can't ratio the "infinities"
  2944.      * so drop out by returning the INRANGE point. 
  2945.      *
  2946.      * Obviously, only need to test the OUTRANGE point (coordinates) */
  2947.     if (ox == -VERYLARGE || oy == -VERYLARGE) {
  2948.     *ex = ix;
  2949.     *ey = iy;
  2950.  
  2951.     if (ox == -VERYLARGE) {
  2952.         /* can't get a direction to draw line, so simply
  2953.          * return INRANGE point */
  2954.         if (oy == -VERYLARGE)
  2955.         return;
  2956.  
  2957.         *ex = x_min;
  2958.         return;
  2959.     }
  2960.     /* obviously oy is -VERYLARGE and ox != -VERYLARGE */
  2961.     *ey = y_min;
  2962.     return;
  2963.     }
  2964.     /*
  2965.      * Can't have case (ix == ox && iy == oy) as one point
  2966.      * is INRANGE and one point is OUTRANGE.
  2967.      */
  2968.     if (iy == oy) {
  2969.     /* horizontal line */
  2970.     /* assume inrange(iy, y_min, y_max) */
  2971.     *ey = iy;        /* == oy */
  2972.  
  2973.     if (inrange(x_max, ix, ox))
  2974.         *ex = x_max;
  2975.     else if (inrange(x_min, ix, ox))
  2976.         *ex = x_min;
  2977.     else {
  2978.         graph_error("error in edge_intersect");
  2979.     }
  2980.     return;
  2981.     } else if (ix == ox) {
  2982.     /* vertical line */
  2983.     /* assume inrange(ix, x_min, x_max) */
  2984.     *ex = ix;        /* == ox */
  2985.  
  2986.     if (inrange(y_max, iy, oy))
  2987.         *ey = y_max;
  2988.     else if (inrange(y_min, iy, oy))
  2989.         *ey = y_min;
  2990.     else {
  2991.         graph_error("error in edge_intersect");
  2992.     }
  2993.     return;
  2994.     }
  2995.     /* slanted line of some kind */
  2996.  
  2997.     /* does it intersect y_min edge */
  2998.     if (inrange(y_min, iy, oy) && y_min != iy && y_min != oy) {
  2999.     x = ix + (y_min - iy) * ((ox - ix) / (oy - iy));
  3000.     if (inrange(x, x_min, x_max)) {
  3001.         *ex = x;
  3002.         *ey = y_min;
  3003.         return;        /* yes */
  3004.     }
  3005.     }
  3006.     /* does it intersect y_max edge */
  3007.     if (inrange(y_max, iy, oy) && y_max != iy && y_max != oy) {
  3008.     x = ix + (y_max - iy) * ((ox - ix) / (oy - iy));
  3009.     if (inrange(x, x_min, x_max)) {
  3010.         *ex = x;
  3011.         *ey = y_max;
  3012.         return;        /* yes */
  3013.     }
  3014.     }
  3015.     /* does it intersect x_min edge */
  3016.     if (inrange(x_min, ix, ox) && x_min != ix && x_min != ox) {
  3017.     y = iy + (x_min - ix) * ((oy - iy) / (ox - ix));
  3018.     if (inrange(y, y_min, y_max)) {
  3019.         *ex = x_min;
  3020.         *ey = y;
  3021.         return;
  3022.     }
  3023.     }
  3024.     /* does it intersect x_max edge */
  3025.     if (inrange(x_max, ix, ox) && x_max != ix && x_max != ox) {
  3026.     y = iy + (x_max - ix) * ((oy - iy) / (ox - ix));
  3027.     if (inrange(y, y_min, y_max)) {
  3028.         *ex = x_max;
  3029.         *ey = y;
  3030.         return;
  3031.     }
  3032.     }
  3033.     /* If we reach here, the inrange point is on the edge, and
  3034.      * the line segment from the outrange point does not cross any 
  3035.      * other edges to get there. In this case, we return the inrange 
  3036.      * point as the 'edge' intersection point. This will basically draw
  3037.      * line.
  3038.      */
  3039.     *ex = ix;
  3040.     *ey = iy;
  3041.     return;
  3042. }
  3043.  
  3044. /* XXX - JG  */
  3045. /* single edge intersection algorithm for "steps" curves */
  3046. /* 
  3047.  * Given two points, one inside and one outside the plot, return
  3048.  * the point where an edge of the plot intersects the line segments
  3049.  * forming the step between the two points. 
  3050.  *
  3051.  * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from  
  3052.  * P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and 
  3053.  * (x2,y1)->(x2,y2). 
  3054.  */
  3055. static void edge_intersect_steps(points, i, ex, ey)
  3056. struct coordinate GPHUGE *points;    /* the points array */
  3057. int i;                /* line segment from point i-1 to point i */
  3058. double *ex, *ey;        /* the point where it crosses an edge */
  3059. {
  3060.     /* global x_min, x_max, y_min, x_max */
  3061.     double ax = points[i - 1].x;
  3062.     double ay = points[i - 1].y;
  3063.     double bx = points[i].x;
  3064.     double by = points[i].y;
  3065.  
  3066.     if (points[i].type == INRANGE) {    /* from OUTRANGE to INRANG */
  3067.     if (inrange(ay, y_min, y_max)) {
  3068.         *ey = ay;
  3069.         if (ax > x_max)
  3070.         *ex = x_max;
  3071.         else        /* x < x_min */
  3072.         *ex = x_min;
  3073.     } else {
  3074.         *ex = bx;
  3075.         if (ay > y_max)
  3076.         *ey = y_max;
  3077.         else        /* y < y_min */
  3078.         *ey = y_min;
  3079.     }
  3080.     } else {            /* from INRANGE to OUTRANGE */
  3081.     if (inrange(bx, x_min, x_max)) {
  3082.         *ex = bx;
  3083.         if (by > y_max)
  3084.         *ey = y_max;
  3085.         else        /* y < y_min */
  3086.         *ey = y_min;
  3087.     } else {
  3088.         *ey = ay;
  3089.         if (bx > x_max)
  3090.         *ex = x_max;
  3091.         else        /* x < x_min */
  3092.         *ex = x_min;
  3093.     }
  3094.     }
  3095.     return;
  3096. }
  3097.  
  3098. /* XXX - HOE  */
  3099. /* single edge intersection algorithm for "fsteps" curves */
  3100. /* fsteps means step on forward y-value. 
  3101.  * Given two points, one inside and one outside the plot, return
  3102.  * the point where an edge of the plot intersects the line segments
  3103.  * forming the step between the two points. 
  3104.  *
  3105.  * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from  
  3106.  * P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and 
  3107.  * (x1,y2)->(x2,y2). 
  3108.  */
  3109. static void edge_intersect_fsteps(points, i, ex, ey)
  3110. struct coordinate GPHUGE *points;    /* the points array */
  3111. int i;                /* line segment from point i-1 to point i */
  3112. double *ex, *ey;        /* the point where it crosses an edge */
  3113. {
  3114.     /* global x_min, x_max, y_min, x_max */
  3115.     double ax = points[i - 1].x;
  3116.     double ay = points[i - 1].y;
  3117.     double bx = points[i].x;
  3118.     double by = points[i].y;
  3119.  
  3120.     if (points[i].type == INRANGE) {    /* from OUTRANGE to INRANG */
  3121.     if (inrange(ax, x_min, x_max)) {
  3122.         *ex = ax;
  3123.         if (ay > y_max)
  3124.         *ey = y_max;
  3125.         else        /* y < y_min */
  3126.         *ey = y_min;
  3127.     } else {
  3128.         *ey = by;
  3129.         if (bx > x_max)
  3130.         *ex = x_max;
  3131.         else        /* x < x_min */
  3132.         *ex = x_min;
  3133.     }
  3134.     } else {            /* from INRANGE to OUTRANGE */
  3135.     if (inrange(by, y_min, y_max)) {
  3136.         *ey = by;
  3137.         if (bx > x_max)
  3138.         *ex = x_max;
  3139.         else        /* x < x_min */
  3140.         *ex = x_min;
  3141.     } else {
  3142.         *ex = ax;
  3143.         if (by > y_max)
  3144.         *ey = y_max;
  3145.         else        /* y < y_min */
  3146.         *ey = y_min;
  3147.     }
  3148.     }
  3149.     return;
  3150. }
  3151.  
  3152. /* XXX - JG  */
  3153. /* double edge intersection algorithm for "steps" plot */
  3154. /* Given two points, both outside the plot, return the points where an 
  3155.  * edge of the plot intersects the line segments forming a step 
  3156.  * by the two points. There may be zero, one, two, or an infinite number
  3157.  * of intersection points. (One means an intersection at a corner, infinite
  3158.  * means overlaying the edge itself). We return FALSE when there is nothing
  3159.  * to draw (zero intersections), and TRUE when there is something to 
  3160.  * draw (the one-point case is a degenerate of the two-point case and we do 
  3161.  * not distinguish it - we draw it anyway).
  3162.  *
  3163.  * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from  
  3164.  * P1 to P2 is drawn as two line segments: (x1,y1)->(x2,y1) and 
  3165.  * (x2,y1)->(x2,y2). 
  3166.  */
  3167. static TBOOLEAN /* any intersection? */
  3168.  two_edge_intersect_steps(points, i, lx, ly)
  3169. struct coordinate GPHUGE *points;    /* the points array */
  3170. int i;                /* line segment from point i-1 to point i */
  3171. double *lx, *ly;        /* lx[2], ly[2]: points where it crosses edges */
  3172. {
  3173.     /* global x_min, x_max, y_min, x_max */
  3174.     double ax = points[i - 1].x;
  3175.     double ay = points[i - 1].y;
  3176.     double bx = points[i].x;
  3177.     double by = points[i].y;
  3178.  
  3179.     if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
  3180.     GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
  3181.     ((ay > y_max || ay < y_min) &&
  3182.      (bx > x_max || bx < x_min))) {
  3183.     return (FALSE);
  3184.     } else if (inrange(ay, y_min, y_max) && inrange(bx, x_min, x_max)) {    /* corner of step inside plotspace */
  3185.     *ly++ = ay;
  3186.     if (ax < x_min)
  3187.         *lx++ = x_min;
  3188.     else
  3189.         *lx++ = x_max;
  3190.  
  3191.     *lx++ = bx;
  3192.     if (by < y_min)
  3193.         *ly++ = y_min;
  3194.     else
  3195.         *ly++ = y_max;
  3196.  
  3197.     return (TRUE);
  3198.     } else if (inrange(ay, y_min, y_max)) {    /* cross plotspace in x-direction */
  3199.     *lx++ = x_min;
  3200.     *ly++ = ay;
  3201.     *lx++ = x_max;
  3202.     *ly++ = ay;
  3203.     return (TRUE);
  3204.     } else if (inrange(ax, x_min, x_max)) {    /* cross plotspace in y-direction */
  3205.     *lx++ = bx;
  3206.     *ly++ = y_min;
  3207.     *lx++ = bx;
  3208.     *ly++ = y_max;
  3209.     return (TRUE);
  3210.     } else
  3211.     return (FALSE);
  3212. }
  3213.  
  3214. /* XXX - HOE  */
  3215. /* double edge intersection algorithm for "fsteps" plot */
  3216. /* Given two points, both outside the plot, return the points where an 
  3217.  * edge of the plot intersects the line segments forming a step 
  3218.  * by the two points. There may be zero, one, two, or an infinite number
  3219.  * of intersection points. (One means an intersection at a corner, infinite
  3220.  * means overlaying the edge itself). We return FALSE when there is nothing
  3221.  * to draw (zero intersections), and TRUE when there is something to 
  3222.  * draw (the one-point case is a degenerate of the two-point case and we do 
  3223.  * not distinguish it - we draw it anyway).
  3224.  *
  3225.  * Recall that if P1 = (x1,y1) and P2 = (x2,y2), the step from  
  3226.  * P1 to P2 is drawn as two line segments: (x1,y1)->(x1,y2) and 
  3227.  * (x1,y2)->(x2,y2). 
  3228.  */
  3229. static TBOOLEAN /* any intersection? */
  3230.  two_edge_intersect_fsteps(points, i, lx, ly)
  3231. struct coordinate GPHUGE *points;    /* the points array */
  3232. int i;                /* line segment from point i-1 to point i */
  3233. double *lx, *ly;        /* lx[2], ly[2]: points where it crosses edges */
  3234. {
  3235.     /* global x_min, x_max, y_min, x_max */
  3236.     double ax = points[i - 1].x;
  3237.     double ay = points[i - 1].y;
  3238.     double bx = points[i].x;
  3239.     double by = points[i].y;
  3240.  
  3241.     if (GPMAX(ax, bx) < x_min || GPMIN(ax, bx) > x_max ||
  3242.     GPMAX(ay, by) < y_min || GPMIN(ay, by) > y_max ||
  3243.     ((by > y_max || by < y_min) &&
  3244.      (ax > x_max || ax < x_min))) {
  3245.     return (FALSE);
  3246.     } else if (inrange(by, y_min, y_max) && inrange(ax, x_min, x_max)) {    /* corner of step inside plotspace */
  3247.     *lx++ = ax;
  3248.     if (ay < y_min)
  3249.         *ly++ = y_min;
  3250.     else
  3251.         *ly++ = y_max;
  3252.  
  3253.     *ly = by;
  3254.     if (bx < x_min)
  3255.         *lx = x_min;
  3256.     else
  3257.         *lx = x_max;
  3258.  
  3259.     return (TRUE);
  3260.     } else if (inrange(by, y_min, y_max)) {    /* cross plotspace in x-direction */
  3261.     *lx++ = x_min;
  3262.     *ly++ = by;
  3263.     *lx = x_max;
  3264.     *ly = by;
  3265.     return (TRUE);
  3266.     } else if (inrange(ax, x_min, x_max)) {    /* cross plotspace in y-direction */
  3267.     *lx++ = ax;
  3268.     *ly++ = y_min;
  3269.     *lx = ax;
  3270.     *ly = y_max;
  3271.     return (TRUE);
  3272.     } else
  3273.     return (FALSE);
  3274. }
  3275.  
  3276. /* double edge intersection algorithm */
  3277. /* Given two points, both outside the plot, return
  3278.  * the points where an edge of the plot intersects the line segment defined 
  3279.  * by the two points. There may be zero, one, two, or an infinite number
  3280.  * of intersection points. (One means an intersection at a corner, infinite
  3281.  * means overlaying the edge itself). We return FALSE when there is nothing
  3282.  * to draw (zero intersections), and TRUE when there is something to 
  3283.  * draw (the one-point case is a degenerate of the two-point case and we do 
  3284.  * not distinguish it - we draw it anyway).
  3285.  */
  3286. static TBOOLEAN /* any intersection? */
  3287.                                two_edge_intersect(points, i, lx, ly)
  3288. struct coordinate GPHUGE *points;    /* the points array */
  3289. int i;                /* line segment from point i-1 to point i */
  3290. double *lx, *ly;        /* lx[2], ly[2]: points where it crosses edges */
  3291. {
  3292.     /* global x_min, x_max, y_min, x_max */
  3293.     int count;
  3294.     double ix = points[i - 1].x;
  3295.     double iy = points[i - 1].y;
  3296.     double ox = points[i].x;
  3297.     double oy = points[i].y;
  3298.     double t[4];
  3299.     double swap;
  3300.     double t_min, t_max;
  3301. #if 0
  3302.     fprintf(stderr, "\ntwo_edge_intersect (%g, %g) and (%g, %g) : ",
  3303.         points[i - 1].x, points[i - 1].y,
  3304.         points[i].x, points[i].y);
  3305. #endif
  3306.     /* nasty degenerate cases, effectively drawing to an infinity point (?)
  3307.        cope with them here, so don't process them as a "real" OUTRANGE point 
  3308.  
  3309.        If more than one coord is -VERYLARGE, then can't ratio the "infinities"
  3310.        so drop out by returning FALSE */
  3311.  
  3312.     count = 0;
  3313.     if (ix == -VERYLARGE)
  3314.     count++;
  3315.     if (ox == -VERYLARGE)
  3316.     count++;
  3317.     if (iy == -VERYLARGE)
  3318.     count++;
  3319.     if (oy == -VERYLARGE)
  3320.     count++;
  3321.  
  3322.     /* either doesn't pass through graph area *or* 
  3323.        can't ratio infinities to get a direction to draw line, so simply return(FALSE) */
  3324.     if (count > 1) {
  3325. #if 0
  3326.     fprintf(stderr, "\tA\n");
  3327. #endif
  3328.     return (FALSE);
  3329.     }
  3330.     if (ox == -VERYLARGE || ix == -VERYLARGE) {
  3331.     if (ix == -VERYLARGE) {
  3332.         /* swap points so ix/iy don't have a -VERYLARGE component */
  3333.         swap = ix;
  3334.         ix = ox;
  3335.         ox = swap;
  3336.         swap = iy;
  3337.         iy = oy;
  3338.         oy = swap;
  3339.     }
  3340.     /* check actually passes through the graph area */
  3341.     if (ix > x_max && inrange(iy, y_min, y_max)) {
  3342.         lx[0] = x_min;
  3343.         ly[0] = iy;
  3344.  
  3345.         lx[1] = x_max;
  3346.         ly[1] = iy;
  3347. #if 0
  3348.         fprintf(stderr, "(%g %g) -> (%g %g)",
  3349.             lx[0], ly[0], lx[1], ly[1]);
  3350. #endif
  3351.         return (TRUE);
  3352.     } else {
  3353. #if 0
  3354.         fprintf(stderr, "\tB\n");
  3355. #endif
  3356.         return (FALSE);
  3357.     }
  3358.     }
  3359.     if (oy == -VERYLARGE || iy == -VERYLARGE) {
  3360.     if (iy == -VERYLARGE) {
  3361.         /* swap points so ix/iy don't have a -VERYLARGE component */
  3362.         swap = ix;
  3363.         ix = ox;
  3364.         ox = swap;
  3365.         swap = iy;
  3366.         iy = oy;
  3367.         oy = swap;
  3368.     }
  3369.     /* check actually passes through the graph area */
  3370.     if (iy > y_max && inrange(ix, x_min, x_max)) {
  3371.         lx[0] = ix;
  3372.         ly[0] = y_min;
  3373.  
  3374.         lx[1] = ix;
  3375.         ly[1] = y_max;
  3376. #if 0
  3377.         fprintf(stderr, "(%g %g) -> (%g %g)",
  3378.             lx[0], ly[0], lx[1], ly[1]);
  3379. #endif
  3380.         return (TRUE);
  3381.     } else {
  3382. #if 0
  3383.         fprintf(stderr, "\tC\n");
  3384. #endif
  3385.         return (FALSE);
  3386.     }
  3387.     }
  3388.     /*
  3389.      * Special horizontal/vertical, etc. cases are checked and remaining
  3390.      * slant lines are checked separately.
  3391.      *
  3392.      * The slant line intersections are solved using the parametric form
  3393.      * of the equation for a line, since if we test x/y min/max planes explicitly
  3394.      * then e.g. a  line passing through a corner point (x_min,y_min) 
  3395.      * actually intersects 2 planes and hence further tests would be required 
  3396.      * to anticipate this and similar situations.
  3397.      */
  3398.  
  3399.     /*
  3400.      * Can have case (ix == ox && iy == oy) as both points OUTRANGE
  3401.      */
  3402.     if (ix == ox && iy == oy) {
  3403.     /* but as only define single outrange point, can't intersect graph area */
  3404.     return (FALSE);
  3405.     }
  3406.     if (ix == ox) {
  3407.     /* line parallel to y axis */
  3408.  
  3409.     /* x coord must be in range, and line must span both y_min and y_max */
  3410.     /* note that spanning y_min implies spanning y_max, as both points OUTRANGE */
  3411.     if (!inrange(ix, x_min, x_max)) {
  3412.         return (FALSE);
  3413.     }
  3414.     if (inrange(y_min, iy, oy)) {
  3415.         lx[0] = ix;
  3416.         ly[0] = y_min;
  3417.  
  3418.         lx[1] = ix;
  3419.         ly[1] = y_max;
  3420. #if 0
  3421.         fprintf(stderr, "(%g %g) -> (%g %g)",
  3422.             lx[0], ly[0], lx[1], ly[1]);
  3423. #endif
  3424.         return (TRUE);
  3425.     } else
  3426.         return (FALSE);
  3427.     }
  3428.     if (iy == oy) {
  3429.     /* already checked case (ix == ox && iy == oy) */
  3430.  
  3431.     /* line parallel to x axis */
  3432.     /* y coord must be in range, and line must span both x_min and x_max */
  3433.     /* note that spanning x_min implies spanning x_max, as both points OUTRANGE */
  3434.     if (!inrange(iy, y_min, y_max)) {
  3435.         return (FALSE);
  3436.     }
  3437.     if (inrange(x_min, ix, ox)) {
  3438.         lx[0] = x_min;
  3439.         ly[0] = iy;
  3440.  
  3441.         lx[1] = x_max;
  3442.         ly[1] = iy;
  3443. #if 0
  3444.         fprintf(stderr, "(%g %g) -> (%g %g)",
  3445.             lx[0], ly[0], lx[1], ly[1]);
  3446. #endif
  3447.         return (TRUE);
  3448.     } else
  3449.         return (FALSE);
  3450.     }
  3451.     /* nasty 2D slanted line in an xy plane */
  3452.  
  3453.     /*
  3454.        Solve parametric equation
  3455.  
  3456.        (ix, iy) + t (diff_x, diff_y)
  3457.  
  3458.        where 0.0 <= t <= 1.0 and
  3459.  
  3460.        diff_x = (ox - ix);
  3461.        diff_y = (oy - iy);
  3462.      */
  3463.  
  3464.     t[0] = (x_min - ix) / (ox - ix);
  3465.     t[1] = (x_max - ix) / (ox - ix);
  3466.  
  3467.     if (t[0] > t[1]) {
  3468.     swap = t[0];
  3469.     t[0] = t[1];
  3470.     t[1] = swap;
  3471.     }
  3472.     t[2] = (y_min - iy) / (oy - iy);
  3473.     t[3] = (y_max - iy) / (oy - iy);
  3474.  
  3475.     if (t[2] > t[3]) {
  3476.     swap = t[2];
  3477.     t[2] = t[3];
  3478.     t[3] = swap;
  3479.     }
  3480.     t_min = GPMAX(GPMAX(t[0], t[2]), 0.0);
  3481.     t_max = GPMIN(GPMIN(t[1], t[3]), 1.0);
  3482.  
  3483.     if (t_min > t_max)
  3484.     return (FALSE);
  3485.  
  3486.     lx[0] = ix + t_min * (ox - ix);
  3487.     ly[0] = iy + t_min * (oy - iy);
  3488.  
  3489.     lx[1] = ix + t_max * (ox - ix);
  3490.     ly[1] = iy + t_max * (oy - iy);
  3491.  
  3492.     /*
  3493.      * Can only have 0 or 2 intersection points -- only need test one coord
  3494.      */
  3495.     if (inrange(lx[0], x_min, x_max) &&
  3496.     inrange(ly[0], y_min, y_max)) {
  3497. #if 0
  3498.     fprintf(stderr, "(%g %g) -> (%g %g)",
  3499.         lx[0], ly[0], lx[1], ly[1]);
  3500. #endif
  3501.     return (TRUE);
  3502.     }
  3503.     return (FALSE);
  3504. }
  3505.  
  3506. /* justify ticplace to a proper date-time value */
  3507. double time_tic_just(level, ticplace)
  3508. int level;
  3509. double ticplace;
  3510. {
  3511.     struct tm tm;
  3512.  
  3513.     if (level <= 0) {
  3514.     return (ticplace);
  3515.     }
  3516.     ggmtime(&tm, (double) ticplace);
  3517.     if (level > 0) {        /* units of minutes */
  3518.     if (tm.tm_sec > 50)
  3519.         tm.tm_min++;
  3520.     tm.tm_sec = 0;
  3521.     }
  3522.     if (level > 1) {        /* units of hours */
  3523.     if (tm.tm_min > 50)
  3524.         tm.tm_hour++;
  3525.     tm.tm_min = 0;
  3526.     }
  3527.     if (level > 2) {        /* units of days */
  3528.     if (tm.tm_hour > 14) {
  3529.         tm.tm_hour = 0;
  3530.         tm.tm_mday = 0;
  3531.         tm.tm_yday++;
  3532.         ggmtime(&tm, (double) gtimegm(&tm));
  3533.     } else if (tm.tm_hour > 7) {
  3534.         tm.tm_hour = 12;
  3535.     } else if (tm.tm_hour > 3) {
  3536.         tm.tm_hour = 6;
  3537.     } else {
  3538.         tm.tm_hour = 0;
  3539.     }
  3540.     }
  3541.     /* skip it, I have not bothered with weekday so far */
  3542.     if (level > 4) {        /* units of month */
  3543.     if (tm.tm_mday > 25) {
  3544.         tm.tm_mon++;
  3545.         if (tm.tm_mon > 11) {
  3546.         tm.tm_year++;
  3547.         tm.tm_mon = 0;
  3548.         }
  3549.     }
  3550.     tm.tm_mday = 1;
  3551.     }
  3552.     if (level > 5) {
  3553.     if (tm.tm_mon >= 7)
  3554.         tm.tm_year++;
  3555.     tm.tm_mon = 0;
  3556.     }
  3557.     ticplace = (double) gtimegm(&tm);
  3558.     ggmtime(&tm, (double) gtimegm(&tm));
  3559.     return (ticplace);
  3560. }
  3561.  
  3562. /* make smalltics for time-axis */
  3563. double make_ltic(tlevel, incr)
  3564. int tlevel;
  3565. double incr;
  3566. {
  3567.     double tinc;
  3568.     tinc = 0;
  3569.     if (tlevel < 0)
  3570.     tlevel = 0;
  3571.     switch (tlevel) {
  3572.     case 0:
  3573.     case 1:{
  3574.         if (incr >= 20)
  3575.         tinc = 10;
  3576.         if (incr >= 60)
  3577.         tinc = 30;
  3578.         if (incr >= 2 * 60)
  3579.         tinc = 60;
  3580.         if (incr >= 5 * 60)
  3581.         tinc = 2 * 60;
  3582.         if (incr >= 10 * 60)
  3583.         tinc = 5 * 60;
  3584.         if (incr >= 20 * 60)
  3585.         tinc = 10 * 60;
  3586.         break;
  3587.     }
  3588.     case 2:{
  3589.         if (incr >= 20 * 60)
  3590.         tinc = 10 * 60;
  3591.         if (incr >= 3600)
  3592.         tinc = 30 * 60;
  3593.         if (incr >= 2 * 3600)
  3594.         tinc = 3600;
  3595.         if (incr >= 5 * 3600)
  3596.         tinc = 2 * 3600;
  3597.         if (incr >= 10 * 3600)
  3598.         tinc = 5 * 3600;
  3599.         if (incr >= 20 * 3600)
  3600.         tinc = 10 * 3600;
  3601.         break;
  3602.     }
  3603.     case 3:{
  3604.         if (incr > 2 * 3600)
  3605.         tinc = 3600;
  3606.         if (incr > 4 * 3600)
  3607.         tinc = 2 * 3600;
  3608.         if (incr > 7 * 3600)
  3609.         tinc = 3 * 3600;
  3610.         if (incr > 13 * 3600)
  3611.         tinc = 6 * 3600;
  3612.         if (incr > DAY_SEC)
  3613.         tinc = 12 * 3600;
  3614.         if (incr > 2 * DAY_SEC)
  3615.         tinc = DAY_SEC;
  3616.         break;
  3617.     }
  3618.     case 4:{            /* week: tic per day */
  3619.         if (incr > 2 * DAY_SEC)
  3620.         tinc = DAY_SEC;
  3621.         if (incr > 7 * DAY_SEC)
  3622.         tinc = 7 * DAY_SEC;
  3623.         break;
  3624.     }
  3625.     case 5:{            /* month */
  3626.         if (incr > 2 * DAY_SEC)
  3627.         tinc = DAY_SEC;
  3628.         if (incr > 15 * DAY_SEC)
  3629.         tinc = 10 * DAY_SEC;
  3630.         if (incr > 2 * MON_SEC)
  3631.         tinc = MON_SEC;
  3632.         if (incr > 6 * MON_SEC)
  3633.         tinc = 3 * MON_SEC;
  3634.         if (incr > 2 * YEAR_SEC)
  3635.         tinc = YEAR_SEC;
  3636.         break;
  3637.     }
  3638.     case 6:{            /* year */
  3639.         if (incr > 2 * MON_SEC)
  3640.         tinc = MON_SEC;
  3641.         if (incr > 6 * MON_SEC)
  3642.         tinc = 3 * MON_SEC;
  3643.         if (incr > 2 * YEAR_SEC)
  3644.         tinc = YEAR_SEC;
  3645.         if (incr > 10 * YEAR_SEC)
  3646.         tinc = 5 * YEAR_SEC;
  3647.         if (incr > 50 * YEAR_SEC)
  3648.         tinc = 10 * YEAR_SEC;
  3649.         if (incr > 100 * YEAR_SEC)
  3650.         tinc = 20 * YEAR_SEC;
  3651.         if (incr > 200 * YEAR_SEC)
  3652.         tinc = 50 * YEAR_SEC;
  3653.         if (incr > 300 * YEAR_SEC)
  3654.         tinc = 100 * YEAR_SEC;
  3655.         break;
  3656.     }
  3657.     }
  3658.     return (tinc);
  3659. }
  3660.  
  3661.  
  3662. void write_multiline(x, y, text, hor, vert, angle, font)
  3663. unsigned int x, y;
  3664. char *text;
  3665. enum JUSTIFY hor;        /* horizontal ... */
  3666. int vert;            /* ... and vertical just - text in hor direction despite angle */
  3667. int angle;            /* assume term has already been set for this */
  3668. char *font;            /* NULL or "" means use default */
  3669. {
  3670.     /* assumes we are free to mangle the text */
  3671.     register struct termentry *t = term;
  3672.     char *p;
  3673.     if (vert != JUST_TOP) {
  3674.     /* count lines and adjust y */
  3675.     int lines = 0;        /* number of linefeeds - one fewer than lines */
  3676.     for (p = text; *p; ++p)
  3677.         if (*p == '\n')
  3678.         ++lines;
  3679.     if (angle)
  3680.         x -= (vert * lines * t->v_char) / 2;
  3681.     else
  3682.         y += (vert * lines * t->v_char) / 2;
  3683.     }
  3684.     if (font && *font)
  3685.     (*t->set_font) (font);
  3686.  
  3687.  
  3688.     for (;;) {            /* we will explicitly break out */
  3689.  
  3690.     if ((p = strchr(text, '\n')) != NULL)
  3691.         *p = 0;        /* terminate the string */
  3692.  
  3693.     if ((*t->justify_text) (hor)) {
  3694.         (*t->put_text) (x, y, text);
  3695.     } else {
  3696.         int fix = hor * (t->h_char) * strlen(text) / 2;
  3697.         if (angle)
  3698.         (*t->put_text) (x, y - fix, text);
  3699.         else
  3700.         (*t->put_text) (x - fix, y, text);
  3701.     }
  3702.     if (angle)
  3703.         x += t->v_char;
  3704.     else
  3705.         y -= t->v_char;
  3706.  
  3707.     if (!p)
  3708.         break;
  3709.  
  3710.     text = p + 1;
  3711.     }                /* unconditional branch back to the for(;;) - just a goto ! */
  3712.  
  3713.     if (font && *font)
  3714.     (*t->set_font) (default_font);
  3715. }
  3716.  
  3717. /* display a x-axis ticmark - called by gen_ticks */
  3718. /* also uses global tic_start, tic_direction, tic_text and tic_just */
  3719. static void xtick2d_callback(axis, place, text, grid)
  3720. int axis;
  3721. double place;
  3722. char *text;
  3723. struct lp_style_type grid;    /* linetype or -2 for no grid */
  3724. {
  3725.     register struct termentry *t = term;
  3726.     /* minitick if text is NULL - beware - h_tic is unsigned */
  3727.     int ticsize = tic_direction * (int) (t->v_tic) * (text ? ticscale : miniticscale);
  3728.     unsigned int x = map_x(place);
  3729.  
  3730.     if (grid.l_type > -2) {
  3731.     term_apply_lp_properties(&grid);
  3732.     if (polar_grid_angle) {
  3733.         double x = place, y = 0, s = sin(0.1), c = cos(0.1);
  3734.         int i;
  3735.         int ogx = map_x(x);
  3736.         int ogy = map_y(0);
  3737.         int tmpgx, tmpgy, gx, gy;
  3738.  
  3739.         if (place > largest_polar_circle)
  3740.         largest_polar_circle = place;
  3741.         else if (-place > largest_polar_circle)
  3742.         largest_polar_circle = -place;
  3743.         for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
  3744.         {
  3745.             /* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
  3746.             double tx = x * c - y * s;
  3747.             /* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
  3748.             y = y * c + x * s;
  3749.             x = tx;
  3750.         }
  3751.         tmpgx = gx = map_x(x);
  3752.         tmpgy = gy = map_y(y);
  3753.         if (clip_line(&ogx, &ogy, &tmpgx, &tmpgy)) {
  3754.             (*t->move) ((unsigned int) ogx, (unsigned int) ogy);
  3755.             (*t->vector) ((unsigned int) tmpgx, (unsigned int) tmpgy);
  3756.         }
  3757.         ogx = gx;
  3758.         ogy = gy;
  3759.         }
  3760.     } else {
  3761.         if (lkey && key_yt > ybot && x < key_xr && x > key_xl) {
  3762.         if (key_yb > ybot) {
  3763.             (*t->move) (x, ybot);
  3764.             (*t->vector) (x, key_yb);
  3765.         }
  3766.         if (key_yt < ytop) {
  3767.             (*t->move) (x, key_yt);
  3768.             (*t->vector) (x, ytop);
  3769.         }
  3770.         } else {
  3771.         (*t->move) (x, ybot);
  3772.         (*t->vector) (x, ytop);
  3773.         }
  3774.     }
  3775.     term_apply_lp_properties(&border_lp);    /* border linetype */
  3776.     }
  3777.     /* we precomputed tic posn and text posn in global vars */
  3778.  
  3779.     (*t->move) (x, tic_start);
  3780.     (*t->vector) (x, tic_start + ticsize);
  3781.  
  3782.     if (tic_mirror >= 0) {
  3783.     (*t->move) (x, tic_mirror);
  3784.     (*t->vector) (x, tic_mirror - ticsize);
  3785.     }
  3786.     if (text)
  3787.     write_multiline(x, tic_text, text, tic_hjust, tic_vjust, rotate_tics, NULL);
  3788. }
  3789.  
  3790. /* display a y-axis ticmark - called by gen_ticks */
  3791. /* also uses global tic_start, tic_direction, tic_text and tic_just */
  3792. static void ytick2d_callback(axis, place, text, grid)
  3793. int axis;
  3794. double place;
  3795. char *text;
  3796. struct lp_style_type grid;    /* linetype or -2 */
  3797. {
  3798.     register struct termentry *t = term;
  3799.     /* minitick if text is NULL - v_tic is unsigned */
  3800.     int ticsize = tic_direction * (int) (t->h_tic) * (text ? ticscale : miniticscale);
  3801.     unsigned int y = map_y(place);
  3802.     if (grid.l_type > -2) {
  3803.     term_apply_lp_properties(&grid);
  3804.     if (polar_grid_angle) {
  3805.         double x = 0, y = place, s = sin(0.1), c = cos(0.1);
  3806.         int i;
  3807.         if (place > largest_polar_circle)
  3808.         largest_polar_circle = place;
  3809.         else if (-place > largest_polar_circle)
  3810.         largest_polar_circle = -place;
  3811.         clip_move(map_x(x), map_y(y));
  3812.         for (i = 1; i <= 63 /* 2pi/0.1 */ ; ++i) {
  3813.         {
  3814.             /* cos(t+dt) = cos(t)cos(dt)-sin(t)cos(dt) */
  3815.             double tx = x * c - y * s;
  3816.             /* sin(t+dt) = sin(t)cos(dt)+cos(t)sin(dt) */
  3817.             y = y * c + x * s;
  3818.             x = tx;
  3819.         }
  3820.         clip_vector(map_x(x), map_y(y));
  3821.         }
  3822.     } else {
  3823.         if (lkey && y < key_yt && y > key_yb && key_xl < xright /* catch TOUT */ ) {
  3824.         if (key_xl > xleft) {
  3825.             (*t->move) (xleft, y);
  3826.             (*t->vector) (key_xl, y);
  3827.         }
  3828.         if (key_xr < xright) {
  3829.             (*t->move) (key_xr, y);
  3830.             (*t->vector) (xright, y);
  3831.         }
  3832.         } else {
  3833.         (*t->move) (xleft, y);
  3834.         (*t->vector) (xright, y);
  3835.         }
  3836.     }
  3837.     term_apply_lp_properties(&border_lp);    /* border linetype */
  3838.     }
  3839.     /* we precomputed tic posn and text posn */
  3840.  
  3841.     (*t->move) (tic_start, y);
  3842.     (*t->vector) (tic_start + ticsize, y);
  3843.  
  3844.     if (tic_mirror >= 0) {
  3845.     (*t->move) (tic_mirror, y);
  3846.     (*t->vector) (tic_mirror - ticsize, y);
  3847.     }
  3848.     if (text)
  3849.     write_multiline(tic_text, y, text, tic_hjust, tic_vjust, rotate_tics, NULL);
  3850. }
  3851.  
  3852. int label_width(str, lines)
  3853. char *str;
  3854. int *lines;
  3855. {
  3856.     char lab[MAX_LINE_LEN + 1], *s, *e;
  3857.     int mlen, len, l;
  3858.  
  3859.     l = mlen = len = 0;
  3860.     sprintf(lab, "%s\n", str);
  3861.     s = lab;
  3862.     while ((e = (char *) strchr(s, '\n')) != NULL) {    /* HBB 980308: quiet BC-3.1 warning */
  3863.     *e = '\0';
  3864.     len = strlen(s);    /* = e-s ? */
  3865.     if (len > mlen)
  3866.         mlen = len;
  3867.     if (len || l)
  3868.         l++;
  3869.     s = ++e;
  3870.     }
  3871.     /* lines = NULL => not interested - div */
  3872.     if (lines)
  3873.     *lines = l;
  3874.     return (mlen);
  3875. }
  3876.  
  3877.  
  3878. void setup_tics(axis, ticdef, format, max)
  3879. int axis;
  3880. struct ticdef *ticdef;
  3881. char *format;
  3882. int max;            /* approx max number of slots available */
  3883. {
  3884.     double tic = 0;        /* HBB: shut up gcc -Wall */
  3885.  
  3886.     int fixmin = (auto_array[axis] & 1) != 0;
  3887.     int fixmax = (auto_array[axis] & 2) != 0;
  3888.  
  3889.     if (ticdef->type == TIC_SERIES) {
  3890.     ticstep[axis] = tic = ticdef->def.series.incr;
  3891.     fixmin &= (ticdef->def.series.start == -VERYLARGE);
  3892.     fixmax &= (ticdef->def.series.end == VERYLARGE);
  3893.     } else if (ticdef->type == TIC_COMPUTED) {
  3894.     ticstep[axis] = tic = make_tics(axis, max);
  3895.     } else {
  3896.     fixmin = fixmax = 0;    /* user-defined, day or month */
  3897.     }
  3898.  
  3899.     if (fixmin) {
  3900.     if (min_array[axis] < max_array[axis])
  3901.         min_array[axis] = tic * floor(min_array[axis] / tic);
  3902.     else
  3903.         min_array[axis] = tic * ceil(min_array[axis] / tic);
  3904.     }
  3905.     if (fixmax) {
  3906.     if (min_array[axis] < max_array[axis])
  3907.         max_array[axis] = tic * ceil(max_array[axis] / tic);
  3908.     else
  3909.         max_array[axis] = tic * floor(max_array[axis] / tic);
  3910.     }
  3911.     if (datatype[axis] == TIME && format_is_numeric[axis])
  3912.     /* invent one for them */
  3913.     timetic_format(axis, min_array[axis], max_array[axis]);
  3914.     else
  3915.     strcpy(ticfmt[axis], format);
  3916. }
  3917.  
  3918. /*{{{  mant_exp - split into mantissa and/or exponent */
  3919. static void mant_exp(log_base, x, scientific, m, p)
  3920. double log_base, x;
  3921. int scientific;            /* round to power of 3 */
  3922. double *m;
  3923. int *p;                /* results */
  3924. {
  3925.     int sign = 1;
  3926.     double l10;
  3927.     int power;
  3928.     /*{{{  check 0 */
  3929.     if (x == 0) {
  3930.     if (m)
  3931.         *m = 0;
  3932.     if (p)
  3933.         *p = 0;
  3934.     return;
  3935.     }
  3936.     /*}}} */
  3937.     /*{{{  check -ve */
  3938.     if (x < 0) {
  3939.     sign = (-1);
  3940.     x = (-x);
  3941.     }
  3942.     /*}}} */
  3943.  
  3944.     l10 = log10(x) / log_base;
  3945.     power = floor(l10);
  3946.     if (scientific) {
  3947.     power = 3 * floor(power / 3.0);
  3948.     }
  3949.     if (m)
  3950.     *m = sign * pow(10.0, (l10 - power) * log_base);
  3951.     if (p)
  3952.     *p = power;
  3953. }
  3954. /*}}} */
  3955.  
  3956. /*
  3957.  * Kludge alert!!
  3958.  * Workaround until we have a better solution ...
  3959.  * Note: this assumes that all calls to sprintf in gprintf have
  3960.  * exactly three args. Lars
  3961.  */
  3962. #ifdef HAVE_SNPRINTF
  3963. # define sprintf(str,fmt,arg) \
  3964.     if (snprintf((str),count,(fmt),(arg)) > count) \
  3965.       fprintf (stderr,"%s:%d: Warning: too many digits for format\n",__FILE__,__LINE__)
  3966. #endif
  3967.  
  3968. /*{{{  gprintf */
  3969. /* extended snprintf */
  3970. static void gprintf(dest, count, format, log_base, x)
  3971. char *dest, *format;
  3972. size_t count;
  3973. double log_base, x;        /* we print one number in a number of different formats */
  3974. {
  3975. #define LOC_PI 3.14159265358979323846    /* local definition of PI */
  3976.     char temp[MAX_LINE_LEN];
  3977.     char *t;
  3978.  
  3979.     for (;;) {
  3980.     /*{{{  copy to dest until % */
  3981.     while (*format != '%')
  3982.         if (!(*dest++ = *format++))
  3983.         return;        /* end of format */
  3984.     /*}}} */
  3985.  
  3986.     /*{{{  check for %% */
  3987.     if (format[1] == '%') {
  3988.         *dest++ = '%';
  3989.         format += 2;
  3990.         continue;
  3991.     }
  3992.     /*}}} */
  3993.  
  3994.     /*{{{  copy format part to temp, excluding conversion character */
  3995.     t = temp;
  3996.     *t++ = '%';
  3997.     /* dont put isdigit first since sideeffect in macro is bad */
  3998.     while (*++format == '.' || isdigit((int) *format) ||
  3999.            *format == '-' || *format == '+' || *format == ' ')
  4000.         *t++ = *format;
  4001.     /*}}} */
  4002.  
  4003.     /*{{{  convert conversion character */
  4004.     switch (*format) {
  4005.         /*{{{  x and o */
  4006.     case 'x':
  4007.     case 'X':
  4008.     case 'o':
  4009.     case 'O':
  4010.         t[0] = *format++;
  4011.         t[1] = 0;
  4012.         sprintf(dest, temp, (int) x);
  4013.         dest += strlen(dest);
  4014.         break;
  4015.         /*}}} */
  4016.         /*{{{  e, f and g */
  4017.     case 'e':
  4018.     case 'E':
  4019.     case 'f':
  4020.     case 'F':
  4021.     case 'g':
  4022.     case 'G':
  4023.         t[0] = *format++;
  4024.         t[1] = 0;
  4025.         sprintf(dest, temp, x);
  4026.         dest += strlen(dest);
  4027.         break;
  4028.         /*}}} */
  4029.         /*{{{  l */
  4030.     case 'l':
  4031.         {
  4032.         double mantissa;
  4033.         mant_exp(log_base, x, 0, &mantissa, NULL);
  4034.         t[0] = 'f';
  4035.         t[1] = 0;
  4036.         sprintf(dest, temp, mantissa);
  4037.         dest += strlen(dest);
  4038.         ++format;
  4039.         break;
  4040.         }
  4041.         /*}}} */
  4042.         /*{{{  t */
  4043.     case 't':
  4044.         {
  4045.         double mantissa;
  4046.         mant_exp(1.0, x, 0, &mantissa, NULL);
  4047.         t[0] = 'f';
  4048.         t[1] = 0;
  4049.         sprintf(dest, temp, mantissa);
  4050.         dest += strlen(dest);
  4051.         ++format;
  4052.         break;
  4053.         }
  4054.         /*}}} */
  4055.         /*{{{  s */
  4056.     case 's':
  4057.         {
  4058.         double mantissa;
  4059.         mant_exp(1.0, x, 1, &mantissa, NULL);
  4060.         t[0] = 'f';
  4061.         t[1] = 0;
  4062.         sprintf(dest, temp, mantissa);
  4063.         dest += strlen(dest);
  4064.         ++format;
  4065.         break;
  4066.         }
  4067.         /*}}} */
  4068.         /*{{{  L */
  4069.     case 'L':
  4070.         {
  4071.         int power;
  4072.         mant_exp(log_base, x, 0, NULL, &power);
  4073.         t[0] = 'd';
  4074.         t[1] = 0;
  4075.         sprintf(dest, temp, power);
  4076.         dest += strlen(dest);
  4077.         ++format;
  4078.         break;
  4079.         }
  4080.         /*}}} */
  4081.         /*{{{  T */
  4082.     case 'T':
  4083.         {
  4084.         int power;
  4085.         mant_exp(1.0, x, 0, NULL, &power);
  4086.         t[0] = 'd';
  4087.         t[1] = 0;
  4088.         sprintf(dest, temp, power);
  4089.         dest += strlen(dest);
  4090.         ++format;
  4091.         break;
  4092.         }
  4093.         /*}}} */
  4094.         /*{{{  S */
  4095.     case 'S':
  4096.         {
  4097.         int power;
  4098.         mant_exp(1.0, x, 1, NULL, &power);
  4099.         t[0] = 'd';
  4100.         t[1] = 0;
  4101.         sprintf(dest, temp, power);
  4102.         dest += strlen(dest);
  4103.         ++format;
  4104.         break;
  4105.         }
  4106.         /*}}} */
  4107.         /*{{{  c */
  4108.     case 'c':
  4109.         {
  4110.         int power;
  4111.         mant_exp(1.0, x, 1, NULL, &power);
  4112.         t[0] = 'c';
  4113.         t[1] = 0;
  4114.         power = power / 3 + 6;    /* -18 -> 0, 0 -> 6, +18 -> 12, ... */
  4115.         if (power >= 0 && power <= 12) {
  4116.             sprintf(dest, temp, "afpnum kMGTPE"[power]);
  4117.         } else {
  4118.             /* please extend the range ! */
  4119.             /* name  power   name  power
  4120.                -------------------------
  4121.                atto   -18    Exa    18
  4122.                femto  -15    Peta   15
  4123.                pico   -12    Tera   12
  4124.                nano    -9    Giga    9
  4125.                micro   -6    Mega    6
  4126.                milli   -3    kilo    3   */
  4127.  
  4128.             /* for the moment, print e+21 for example */
  4129.             sprintf(dest, "e%+02d", (power - 6) * 3);
  4130.         }
  4131.  
  4132.         dest += strlen(dest);
  4133.         ++format;
  4134.         break;
  4135.         }
  4136.     case 'P':
  4137.         {
  4138.         t[0] = 'f';
  4139.         t[1] = 0;
  4140.         sprintf(dest, temp, x / LOC_PI);
  4141.         dest += strlen(dest);
  4142.         ++format;
  4143.         break;
  4144.         }
  4145.         /*}}} */
  4146.     default:
  4147.         int_error("Bad format character", NO_CARET);
  4148.     }
  4149.     /*}}} */
  4150.     }
  4151. }
  4152. #undef LOC_PI            /* local definition of PI */
  4153. /*}}} */
  4154. #ifdef HAVE_SNPRINTF
  4155. # undef sprintf
  4156. #endif
  4157.  
  4158.  
  4159.  
  4160. /*{{{  gen_tics */
  4161. /* uses global arrays ticstep[], ticfmt[], min_array[], max_array[],
  4162.  * auto_array[], log_array[], log_base_array[]
  4163.  * we use any of GRID_X/Y/X2/Y2 and  _MX/_MX2/etc - caller is expected
  4164.  * to clear the irrelevent fields from global grid bitmask
  4165.  * note this is also called from graph3d, so we need GRID_Z too
  4166.  */
  4167.  
  4168. void gen_tics(axis, def, grid, minitics, minifreq, callback)
  4169. int axis;            /* FIRST_X_AXIS, etc */
  4170. struct ticdef *def;        /* tic defn */
  4171. int grid;            /* GRID_X | GRID_MX etc */
  4172. int minitics;            /* minitics - off/default/auto/explicit */
  4173. double minifreq;        /* frequency */
  4174. tic_callback callback;        /* fn to call to actually do the work */
  4175. {
  4176.     /* seperate main-tic part of grid */
  4177.     struct lp_style_type lgrd, mgrd;
  4178.  
  4179.     memcpy(&lgrd, &grid_lp, sizeof(struct lp_style_type));
  4180.     memcpy(&mgrd, &mgrid_lp, sizeof(struct lp_style_type));
  4181.     lgrd.l_type = (grid & (GRID_X | GRID_Y | GRID_X2 | GRID_Y2 | GRID_Z)) ? grid_lp.l_type : -2;
  4182.     mgrd.l_type = (grid & (GRID_MX | GRID_MY | GRID_MX2 | GRID_MY2 | GRID_MZ)) ? mgrid_lp.l_type : -2;
  4183.  
  4184.     if (def->type == TIC_USER) {    /* special case */
  4185.     /*{{{  do user tics then return */
  4186.     struct ticmark *mark = def->def.user;
  4187.     double uncertain = (max_array[axis] - min_array[axis]) / 10;
  4188.     double ticmin = min_array[axis] - SIGNIF * uncertain;
  4189.     double internal_max = max_array[axis] + SIGNIF * uncertain;
  4190.     double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
  4191.  
  4192.     /* polar labels always +ve, and if rmin has been set, they are
  4193.      * relative to rmin. position is as user specified, but must
  4194.      * be translated. I dont think it will work at all for
  4195.      * log scale, so I shan't worry about it !
  4196.      */
  4197.     double polar_shift = (polar && !(autoscale_r & 1)) ? rmin : 0;
  4198.  
  4199.     for (mark = def->def.user; mark; mark = mark->next) {
  4200.         char label[64];
  4201.         double internal = log_array[axis] ? log(mark->position) / log_base_array[axis] : mark->position;
  4202.  
  4203.         internal -= polar_shift;
  4204.  
  4205.         if (!inrange(internal, ticmin, internal_max))
  4206.         continue;
  4207.  
  4208.         if (datatype[axis] == TIME)
  4209.         gstrftime(label, 24, mark->label ? mark->label : ticfmt[axis], mark->position);
  4210.         else
  4211.         gprintf(label, sizeof(label), mark->label ? mark->label : ticfmt[axis], log_base, mark->position);
  4212.  
  4213.         (*callback) (axis, internal, label, lgrd);
  4214.     }
  4215.  
  4216.     return;            /* NO MINITICS FOR USER-DEF TICS */
  4217.     /*}}} */
  4218.     }
  4219.     /* series-tics
  4220.      * need to distinguish user co-ords from internal co-ords.
  4221.      * - for logscale, internal = log(user), else internal = user
  4222.      *
  4223.      * The minitics are a bit of a drag - we need to distinuish
  4224.      * the cases step>1 from step == 1.
  4225.      * If step = 1, we are looking at 1,10,100,1000 for example, so
  4226.      * minitics are 2,5,8, ...  - done in user co-ordinates
  4227.      * If step>1, we are looking at 1,1e6,1e12 for example, so
  4228.      * minitics are 10,100,1000,... - done in internal co-ords
  4229.      */
  4230.  
  4231.     {
  4232.     double tic;        /* loop counter */
  4233.     double internal;    /* in internal co-ords */
  4234.     double user;        /* in user co-ords */
  4235.     double start, step, end;
  4236.     double lmin = min_array[axis], lmax = max_array[axis];
  4237.     double internal_min, internal_max;    /* to allow for rounding errors */
  4238.     double ministart = 0, ministep = 1, miniend = 1;    /* internal or user - depends on step */
  4239.     int anyticput = 0;    /* for detection of infinite loop */
  4240.  
  4241.     /* gprintf uses log10() of base - log_base_array is log() */
  4242.     double log_base = log_array[axis] ? log10(base_array[axis]) : 1.0;
  4243.  
  4244.     if (lmax < lmin) {
  4245.         /* hmm - they have set reversed range for some reason */
  4246.         double temp = lmin;
  4247.         lmin = lmax;
  4248.         lmax = temp;
  4249.     }
  4250.     /*{{{  choose start, step and end */
  4251.     switch (def->type) {
  4252.     case TIC_SERIES:
  4253.         if (log_array[axis]) {
  4254.         /* we can tolerate start <= 0 if step and end > 0 */
  4255.         if (def->def.series.end <= 0 ||
  4256.             def->def.series.incr <= 0)
  4257.             return;    /* just quietly ignore */
  4258.         step = log(def->def.series.incr) / log_base_array[axis];
  4259.         end = log(def->def.series.end) / log_base_array[axis];
  4260.         start = def->def.series.start > 0 ?
  4261.             log(def->def.series.start) / log_base_array[axis] :
  4262.             step;
  4263.         } else {
  4264.         start = def->def.series.start;
  4265.         step = def->def.series.incr;
  4266.         end = def->def.series.end;
  4267.         if (start == -VERYLARGE)
  4268.             start = step * floor(lmin / step);
  4269.         if (end == VERYLARGE)
  4270.             end = step * ceil(lmax / step);
  4271.         }
  4272.         break;
  4273.     case TIC_COMPUTED:
  4274.         /* round to multiple of step */
  4275.         start = ticstep[axis] * floor(lmin / ticstep[axis]);
  4276.         step = ticstep[axis];
  4277.         end = ticstep[axis] * ceil(lmax / ticstep[axis]);
  4278.         break;
  4279.     case TIC_MONTH:
  4280.         start = floor(lmin);
  4281.         end = ceil(lmax);
  4282.         step = floor((end - start) / 12);
  4283.         if (step < 1)
  4284.         step = 1;
  4285.         break;
  4286.     case TIC_DAY:
  4287.         start = floor(lmin);
  4288.         end = ceil(lmax);
  4289.         step = floor((end - start) / 14);
  4290.         if (step < 1)
  4291.         step = 1;
  4292.         break;
  4293.     default:
  4294.         graph_error("Internal error : unknown tic type");
  4295.         return;        /* avoid gcc -Wall warning about start */
  4296.     }
  4297.     /*}}} */
  4298.  
  4299.     /*{{{  ensure ascending order */
  4300.     if (end < start) {
  4301.         double temp;
  4302.         temp = end;
  4303.         end = start;
  4304.         start = temp;
  4305.     }
  4306.     step = fabs(step);
  4307.     /*}}} */
  4308.  
  4309.     if (minitics) {
  4310.         /*{{{  figure out ministart, ministep, miniend */
  4311.         if (minitics == MINI_USER) {
  4312.         /* they have said what they want */
  4313.         if (minifreq <= 0)
  4314.             minitics = 0;    /* not much else we can do */
  4315.         else if (log_array[axis]) {
  4316.             ministart = ministep = step / minifreq * base_array[axis];
  4317.             miniend = step * base_array[axis];
  4318.         } else {
  4319.             ministart = ministep = step / minifreq;
  4320.             miniend = step;
  4321.         }
  4322.         } else if (log_array[axis]) {
  4323.         if (step > 1.5) {    /* beware rounding errors */
  4324.             /*{{{  10,100,1000 case */
  4325.             /* no more than five minitics */
  4326.             ministart = ministep = (int) (0.2 * step);
  4327.             if (ministep < 1)
  4328.             ministart = ministep = 1;
  4329.             miniend = step;
  4330.             /*}}} */
  4331.         } else {
  4332.             /*{{{  2,5,8 case */
  4333.             miniend = base_array[axis];
  4334.             if (end - start >= 10)
  4335.             minitics = 0;    /* none */
  4336.             else if (end - start >= 5) {
  4337.             ministart = 2;
  4338.             ministep = 3;
  4339.             } else {
  4340.             ministart = 2;
  4341.             ministep = 1;
  4342.             }
  4343.             /*}}} */
  4344.         }
  4345.         } else if (datatype[axis] == TIME) {
  4346.         ministart = ministep = make_ltic(timelevel[axis], step);
  4347.         miniend = step * 0.9;
  4348.         } else if (minitics == MINI_AUTO) {
  4349.         ministart = ministep = 0.1 * step;
  4350.         miniend = step;
  4351.         } else
  4352.         minitics = 0;
  4353.  
  4354.         if (ministep <= 0)
  4355.         minitics = 0;    /* dont get stuck in infinite loop */
  4356.         /*}}} */
  4357.     }
  4358.     /*{{{  a few tweaks and checks */
  4359.     /* watch rounding errors */
  4360.     end += SIGNIF * step;
  4361.     internal_max = lmax + step * SIGNIF;
  4362.     internal_min = lmin - step * SIGNIF;
  4363.  
  4364.     if (step == 0)
  4365.         return;        /* just quietly ignore them ! */
  4366.     /*}}} */
  4367.  
  4368.     for (tic = start; tic <= end; tic += step) {
  4369.         if (anyticput == 2)    /* See below... */
  4370.         break;
  4371.         if (anyticput && (fabs(tic - start) < DBL_EPSILON)) {
  4372.         /* step is too small.. */
  4373.         anyticput = 2;    /* Don't try again. */
  4374.         tic = end;    /* Put end tic. */
  4375.         } else
  4376.         anyticput = 1;
  4377.  
  4378.         /*{{{  calc internal and user co-ords */
  4379.         if (!log_array[axis]) {
  4380.         internal = datatype[axis] == TIME ? time_tic_just(timelevel[axis], tic) : tic;
  4381.         user = CheckZero(internal, step);
  4382.         } else {
  4383.         /* log scale => dont need to worry about zero ? */
  4384.         internal = tic;
  4385.         user = pow(base_array[axis], internal);
  4386.         }
  4387.         /*}}} */
  4388.         if (internal > internal_max)
  4389.         break;        /* gone too far - end of series = VERYLARGE perhaps */
  4390.         if (internal >= internal_min) {
  4391. /* continue; *//* maybe minitics!!!. user series starts below min ? */
  4392.  
  4393.         /*{{{  draw tick via callback */
  4394.         switch (def->type) {
  4395.         case TIC_DAY:{
  4396.             int d = (long) floor(user + 0.5) % 7;
  4397.             if (d < 0)
  4398.                 d += 7;
  4399.             (*callback) (axis, internal, abbrev_day_names[d], lgrd);
  4400.             break;
  4401.             }
  4402.         case TIC_MONTH:{
  4403.             int m = (long) floor(user - 1) % 12;
  4404.             if (m < 0)
  4405.                 m += 12;
  4406.             (*callback) (axis, internal, abbrev_month_names[m], lgrd);
  4407.             break;
  4408.             }
  4409.         default:{    /* comp or series */
  4410.             char label[64];
  4411.             if (datatype[axis] == TIME) {
  4412.                 /* If they are doing polar time plot, good luck to them */
  4413.                 gstrftime(label, 24, ticfmt[axis], (double) user);
  4414.             } else if (polar) {
  4415.                 /* if rmin is set, we stored internally with r-rmin */
  4416. #if 0                /* Igor's polar-grid patch */
  4417.                 double r = fabs(user) + (autoscale_r & 1 ? 0 : rmin);
  4418. #else
  4419.                 /* Igor removed fabs to allow -ve labels */
  4420.                 double r = user + (autoscale_r & 1 ? 0 : rmin);
  4421. #endif
  4422.                 gprintf(label, sizeof(label), ticfmt[axis], log_base, r);
  4423.             } else {
  4424.                 gprintf(label, sizeof(label), ticfmt[axis], log_base, user);
  4425.             }
  4426.             (*callback) (axis, internal, label, lgrd);
  4427.             }
  4428.         }
  4429.         /*}}} */
  4430.  
  4431.         }
  4432.         if (minitics) {
  4433.         /*{{{  process minitics */
  4434.         double mplace, mtic;
  4435.         for (mplace = ministart; mplace < miniend; mplace += ministep) {
  4436.             if (datatype[axis] == TIME)
  4437.             mtic = time_tic_just(timelevel[axis] - 1, internal + mplace);
  4438.             else
  4439.             mtic = internal + (log_array[axis] && step <= 1.5 ? log(mplace) / log_base_array[axis] : mplace);
  4440.             if (inrange(mtic, internal_min, internal_max) &&
  4441.             inrange(mtic, start - step * SIGNIF, end + step * SIGNIF))
  4442.             (*callback) (axis, mtic, NULL, mgrd);
  4443.         }
  4444.         /*}}} */
  4445.         }
  4446.     }
  4447.     }
  4448. }
  4449. /*}}} */
  4450.  
  4451. /*{{{  map_position */
  4452. static void map_position(pos, x, y, what)
  4453. struct position *pos;
  4454. unsigned int *x, *y;
  4455. char *what;
  4456. {
  4457.     switch (pos->scalex) {
  4458.     case first_axes:
  4459.     {
  4460.         double xx = LogScale(pos->x, log_array[FIRST_X_AXIS], log_base_array[FIRST_X_AXIS], what, "x");
  4461.         *x = xleft + (xx - min_array[FIRST_X_AXIS]) * scale[FIRST_X_AXIS] + 0.5;
  4462.         break;
  4463.     }
  4464.     case second_axes:
  4465.     {
  4466.         double xx = LogScale(pos->x, log_array[SECOND_X_AXIS], log_base_array[SECOND_X_AXIS], what, "x");
  4467.         *x = xleft + (xx - min_array[SECOND_X_AXIS]) * scale[SECOND_X_AXIS] + 0.5;
  4468.         break;
  4469.     }
  4470.     case graph:
  4471.     {
  4472.         *x = xleft + pos->x * (xright - xleft) + 0.5;
  4473.         break;
  4474.     }
  4475.     case screen:
  4476.     {
  4477.         register struct termentry *t = term;
  4478.         *x = pos->x * (t->xmax) + 0.5;
  4479.         break;
  4480.     }
  4481.     }
  4482.     switch (pos->scaley) {
  4483.     case first_axes:
  4484.     {
  4485.         double yy = LogScale(pos->y, log_array[FIRST_Y_AXIS], log_base_array[FIRST_Y_AXIS], what, "y");
  4486.         *y = ybot + (yy - min_array[FIRST_Y_AXIS]) * scale[FIRST_Y_AXIS] + 0.5;
  4487.         return;
  4488.     }
  4489.     case second_axes:
  4490.     {
  4491.         double yy = LogScale(pos->y, log_array[SECOND_Y_AXIS], log_base_array[SECOND_Y_AXIS], what, "y");
  4492.         *y = ybot + (yy - min_array[SECOND_Y_AXIS]) * scale[SECOND_Y_AXIS] + 0.5;
  4493.         return;
  4494.     }
  4495.     case graph:
  4496.     {
  4497.         *y = ybot + pos->y * (ytop - ybot) + 0.5;
  4498.         return;
  4499.     }
  4500.     case screen:
  4501.     {
  4502.         register struct termentry *t = term;
  4503.         *y = pos->y * (t->ymax) + 0.5;
  4504.         return;
  4505.     }
  4506.     }
  4507. }
  4508. /*}}} */
  4509.